Discussion :

[touftouf57]

Bonjour,

Il m'a été demandé de faire un winform d'attente sur le compact framework 3.5.

En fait j'ai un terminal mobile (d'où le Compact Framework) qui envoie des message via TCP. J'avais géré les cas ou la communication ne fonctionnait pas.
Mais ce qu'il peut arriver c'est que la communication fonctionne mais que le serveur plante, ou lève une exception pendant le traitement de la demande et s'arrète.
Cela fait que le terminal attend une réponse à sa demande qu'il n'aura jamais.

Vu que j'empêche le terminal d'envoyer la même demande plusieurs fois d'affilé, en rendant indisponible le bouton. Si c'est le serveur qui merde, l'application du terminal ne peut plus avancer.

Voila en gros le principe:
Je clic sur "nouvel identifiant"
Je met enable=false sur le bouton
Le terminal envoie la demande au serveur
Le serveur recoit la demande
Le serveur fait un create dans la base
Le serveur récupère l'ID
Le serveur renvoie l'ID au terminal qui lui a demandé
Le terminal recoit le nouvel ID

Maintenant si la phase d'acces à la base foire, je ne peux pas renvoyer de demande d'identifiant au serveur. Et le terminal ne sait pas du tout ce qu'il se passe.

On m'a donc demandé de faire une winform avec un Gif de préférence, et un unique bouton permettant "d'annuler" la demande. Et de remettre l'application dans l'état dans lequel elle se trouvait avant la demande.

Donc je me dis qu'il faut que je fasse une winform qui lance un thread lorsqu'elle s'affiche. J'aurais au préalable instancié un délegate qui "pointera" sur la méthode d'envoi souhaité (demande d'id, annulation....).
Et lorsque je clic sur le bouton "annuler" je kill le thread.

Mais je ne sais pas si c'est une bonne technique, ni comment la mettre en place. Je connais le principe des threads et des delegates, mais j'ai du mal à le mettre en place.

voila ce que j'ai essayé, mais la fenêtre ne s'affiche pas correctement.

Code :

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

1
2
3
4
public void DemandeNewIDReception() {
        this._frmReception.TopMost=false;
                FrmWaiter waiter = new FrmWaiter(_emetteur.DemandeNewIDReception);
                waiter.ShowDialog();

avec _emetteur.DemandeNewIDReception qui est le delegate pointant sur la méthode demandé.

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
 public partial class FrmWaiter : Form {
        private Thread _thread;
//MethodeDemande étant un delegate. Signatire void MethodeDemande()
        private MethodeDemande _demande;
        private bool _stopThread = false;
 
        public FrmWaiter(MethodeDemande demande) {
            InitializeComponent();
            _demande = demande;
            _thread = new Thread(new ThreadStart(DemarreThread));
        }
 
        public void button1_Click(object sender, EventArgs e) {
            this._stopThread=true;
        }
 
 
        private void DemarreThread() {
            _demande.Invoke();
            while (!this._stopThread) {
                continue;
            }
        }
 
        private void FrmWaiter_Activated(object sender, EventArgs e) {
            _thread.Start();
            _thread.Join();
        }
    }
}

Merci de vos conseils avisés.

[thelpi]

Salut,

voila ma méthode, j'utilise un BackgroundWorker plutôt qu'un thread et elle est générique pour toutes les actions longues de mon application:

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
 
/// <summary>
    /// classe de gestion des méthodes longues
    /// </summary>
    /// <remarks>utilise un thread parallèle et une fenêtre à ProgressBar</remarks>
    public class ThreadManager
    {
        /// <summary>
        /// instance unique (Singleton)
        /// </summary>
        private static ThreadManager _instance = null;
        /// <summary>
        /// fenêtre de ProgressBar
        /// </summary>
        private wdwWait frmWait;
        /// <summary>
        /// booléen déterminant si l'opération s'est déroulée entièrement
        /// </summary>
        private bool OperationIsSuccess;
        /// <summary>
        /// exécutant de fond
        /// </summary>
        private BackgroundWorker bgw;
 
        /// <summary>
        /// constructeur privé
        /// </summary>
        private ThreadManager()
        {
            OperationIsSuccess = false;
        }
 
        /// <summary>
        /// acesseur sur l'instance
        /// </summary>
        public static ThreadManager Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new ThreadManager();
                return _instance;
            }
        }
 
        /// <summary>
        /// démarre le thread parallèle
        /// </summary>
        /// <param name="_callBack">méthode lancé par le thread</param>
        /// <param name="_actionName">intitulé de l'action</param>
        /// <param name="_abortMessage">message en cas d'abandon</param>
        /// <param name="_allowQuit">détermine si l'action peut être interrompue</param>
        /// <returns>succès ou échec de l'opération</returns>
        public bool Launch(DoWorkEventHandler _callBack, string _actionName, string _abortMessage, bool _allowQuit)
        {
            bgw = new BackgroundWorker();
            bgw.WorkerReportsProgress = true;
            bgw.WorkerSupportsCancellation = true;
            bgw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgw_RunWorkerCompleted);
            bgw.DoWork += new DoWorkEventHandler(_callBack);
            bgw.ProgressChanged += new ProgressChangedEventHandler(bgw_ProgressChanged);
            bgw.RunWorkerAsync();
 
            frmWait = new wdwWait(_actionName, _abortMessage, _allowQuit);
            frmWait.Closed += new EventHandler(frmWait_Closed);
            frmWait.ShowDialog();
 
            return OperationIsSuccess;
        }
 
        /// <summary>
        /// se produit quand la pgroession est modifiée
        /// </summary>
        /// <param name="sender">objet appelant</param>
        /// <param name="evt">données de l'évènement</param>
        private void bgw_ProgressChanged(object sender, ProgressChangedEventArgs evt)
        {
            this.frmWait.Dispatcher.Invoke(new ProgressionHandler(frmWait.SetProgressBarChanged), evt.ProgressPercentage);
        }
 
        /// <summary>
        /// se produit quand la fenêtre d'attente est fermée
        /// </summary>
        /// <param name="sender">objet appelant</param>
        /// <param name="e">évenement levé</param>
        private void frmWait_Closed(object sender, EventArgs e)
        {
            bgw.CancelAsync();
        }
 
        /// <summary>
        /// se produit quand l'exécutant a terminé son travail
        /// </summary>
        /// <param name="sender">objet appelant</param>
        /// <param name="evt">données de l'évènement</param>
        private void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs evt)
        {
            frmWait.Hide();
            OperationIsSuccess = !evt.Cancelled;
        }
    }

Elle est loin d'être parfaite cependant (je dois passer le BackgroundWorker à la fenetre d'attente ) et est faite pour du Wpf et pas du Windows Forms (donc enlève le Dispatcher)

Je ne t'ai pas envoyé le constructeur de la fenêtre mais l'idée c'est qu'elle vérifie à sa fermeture si elle est autorisée à se fermer avec "_allowQuit", en affichant à ce moment là le message "_abortMessage"

En espérant que ça t'aide

@+