Discussion :

[lucas67]

Bonjour,

Je suis débutant en C# et je tombe sur un problème au niveau de l’affichage de mon WinForm.

J’ai décidé de bien séparer la partie «*graphique*» de la partie «*traitement*» dans mon projet. Pour cela je lance un «*thread*» qui va représenter le schéma bloc de mon appli (graphcet). Je gère les étapes à l’aide d’un "switch/case" et d’une variable externe. Si cette dernière prend, par exemple, la valeur «*open_fenetre_1*» alors je fais un fenetre_1.show() puis je me mets en attente (variable externe = attente).

Mon appli ne se ferme pas car j’attends un événement que j’active quand je veux quitter.

Le code est le suivant*:

Programme main*:

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
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Threading;
 
namespace Essai_Show_Appli_Windows
{
    static class Program
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
 
            Cls_Traitement.ref_Frm_Windows_1 = new Frm_Windows_1();
            Cls_Traitement.ref_Frm_Windows_2 = new Frm_Windows_2();
 
            Cls_Traitement.MonEvent = new System.Threading.EventWaitHandle(false, EventResetMode.ManualReset);
 
            Cls_Traitement.case_etat_fenetre = Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN;
 
            Cls_Traitement.MonThread = new System.Threading.Thread(Cls_Traitement.ThreadProc);
            Cls_Traitement.case_etat_fenetre = Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN;
            Cls_Traitement.MonThread.Start();
 
 
            Cls_Traitement.MonEvent.WaitOne();
        }
    }
}

Classe traitement*:

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
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Windows.Forms;
 
namespace Essai_Show_Appli_Windows
{
    class Cls_Traitement
    {
        public enum Etat_Fenetre
        {
            //Etat Fenêtre Choix version ODISSEE
            SELECT_IHM_ChoixVersion_OPEN,
            SELECT_IHM_ChoixVersion_CLOSE,
            SELECT_IHM_ChoixVersion_WAIT
         }; //Liste des états possibles pour chaque fenêtre 
 
        public static Etat_Fenetre case_etat_fenetre;
        public static bool bool_sortie_boucle_processus;
 
        public static Frm_Windows_1 ref_Frm_Windows_1;
        public static Frm_Windows_2 ref_Frm_Windows_2;
 
        public static Thread MonThread;
        public static EventWaitHandle MonEvent;
 
 
        public static void ThreadProc()
        {
            while (Cls_Traitement.bool_sortie_boucle_processus == false)
            {
                switch ( Cls_Traitement.case_etat_fenetre)
                {
                    case Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN :
 
                        Cls_Traitement.ref_Frm_Windows_1.Show();
                        Cls_Traitement.case_etat_fenetre = Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT;
                        break;
 
                    case Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT :
                        // On fait rien (attente du chgt de la variable Etat_Fenetre
                        break;
 
                    case Cls_Traitement.Etat_Fenetre.SELECT_IHM_ChoixVersion_CLOSE :
 
                        Cls_Traitement.ref_Frm_Windows_1.Close();
                        Cls_Traitement.case_etat_fenetre = Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT;
                        Cls_Traitement.bool_sortie_boucle_processus = true;
                        break;
                }
                Thread.Sleep(100);
            }
 
            Cls_Traitement.MonEvent.Set();
        }
    }
}

Mon souci est que la fenêtre ne s’affiche pas correctement (elle est toute blanche). Quel est le problème*??

Merci.

[StormimOn]

Vouloir séparer la partie graphique du traitement c'est bien, mais il faut faire attention à ne pas tout mélanger.

N'ouvre pas tes Form sur un autre thread. C'est uniquement la partie traitement qui doit être réalisée sur un thread séparé, afin de ne pas bloquer le thread principal qui est dédié à l'affichage.

Ca ira beaucoup mieux après.

Tu peux aussi regarder du côté du composant BackgroundWorker. Ca te permettra d'effectuer une tâche dans un autre thread, sans bloquer la fenêtre donc. Le composant fournit plusieurs événement, dont un un événement de progression qui permet de faire des mises à jour sur la partie graphique.

[lucas67]

Merci pour tes conseils, tu as raison j’ai un peu tout mélangé.

Ce que je cherche c’est de garder la main sur mon programme tout en affichant une fenêtre. La méthode «*show*» me paraît correspondre à ce que je cherche mais je n’arrive pas à afficher ma fenêtre correctement (même lorsque je suis dans le thread principal), je n’arrive à afficher une fenêtre avec «*WinForm.show()*» que lorsqu'une première fenêtre et déjà active (avec «*application.run(WinForm)*» par exemple). Mais là comme avec la méthode «*ShowDialog*» je reste arrêté dans mon programme jusqu’à ce que ma fenêtre se ferme.

La solution que j’ai retenue pour l’instant c’est de créer pour chaque fenêtre un thread qui contiendra un «*ShowDialog()*» ainsi la fenêtre est affichée et mon programme principal continue à tourner. Je sépare mieux la partie traitement (où je ne fais que lancer les thread) et la partie graphique (j’ouvre la fenêtre à partir d’une fonction située dans la classe form «*this.ShowDialog()*»).

Pour exemple voici une partie de mon code :

Programme main*:

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
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Threading;
 
namespace Essai_Show_Appli_Windows
{
    static class Program
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            //Initialisation
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
 
            Cls_Define.ref_Frm_Windows_1 = new Frm_Windows_1();
            Cls_Define.ref_Frm_Windows_2 = new Frm_Windows_2();
 
            Cls_Define.Thread_Open_F1 = new System.Threading.Thread(Cls_Define.ref_Frm_Windows_1.fct_thread_open_Windows_1);
            Cls_Define.Thread_Open_F2 = new System.Threading.Thread(Cls_Define.ref_Frm_Windows_2.fct_thread_open_Windows_2);
            //Cls_Traitement.MonEvent = new System.Threading.EventWaitHandle(false, EventResetMode.ManualReset);
 
            Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN_F1;
 
            //Traitement des états des fenêtres
            Cls_Traitement.fct_traitement_etat_fenetre();
 
            //MessageBox.Show("Bye Bye");
            //Cls_Traitement.MonEvent.WaitOne();
        }
    }
}

Classe traitement :

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
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Windows.Forms;
 
namespace Essai_Show_Appli_Windows
{
    class Cls_Traitement
    {
        public static void fct_traitement_etat_fenetre()
        {
            while (Cls_Define.bool_sortie_boucle_processus == false)
            {
                switch (Cls_Define.case_etat_fenetre)
                {
                    case Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN_F1:
 
                        Cls_Define.Thread_Open_F1.Start();
                        Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT;
                        break;
 
                    case Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN_F2:
 
                        Cls_Define.Thread_Open_F1.Abort();
                        Cls_Define.Thread_Open_F2.Start();
                        Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT;
                        break;
 
                    case Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT:
                        // On fait rien (attente du chgt de la variable Etat_Fenetre
                        break;
 
                    case Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_CLOSE:
 
                        Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_WAIT;
                        Cls_Define.bool_sortie_boucle_processus = true;
                        break;
                }
                Thread.Sleep(100);
            }
            //    Cls_Define.MonEvent.Set();
        }
    }
}

Classe fenêtre 1

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
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
namespace Essai_Show_Appli_Windows
{
    public partial class Frm_Windows_1 : Form
    {
        public Frm_Windows_1()
        {
            InitializeComponent();
        }
 
        private void bp_Ouverture_Fenetre_2_Click(object sender, EventArgs e)
        {
            Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_OPEN_F2;
        }
 
        private void FormClosed_Windows_1(object sender, FormClosedEventArgs e)
        {
            Cls_Define.case_etat_fenetre = Cls_Define.Etat_Fenetre.SELECT_IHM_ChoixVersion_CLOSE;
            Cls_Define.Thread_Open_F1.Abort();
        }
 
        public void fct_thread_open_Windows_1()
        {
            Cls_Define.ref_Frm_Windows_1.ShowDialog();
        }
 
    }
}

S’il y a des points à améliorer ou des remarques faites le moi savoir.

Merci pour votre aide.