Thread, opérations longues et progressbar

Version imprimable

Bonjour à tous,

J'ai une appli en WPF 3.5 qui, avant de lancer sa fenêtre principale, doit effectuer certaines vérifications de pré-requis. Certaines des ces opérations peuvent être longues (plusieurs minutes) donc je me suis dit : thread parallèle + fenêtre affichant une barre de progression indéterminée.

J'ai tenté cela par 2 codes différents, les 2 ne sont pas du tout satisfaisants:

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
 
    /// <summary>
    /// classe gérant les appels au thread d'opérations longues
    /// </summary>
    public class ThreadManager
    {
        private static ThreadManager _instance = null;
        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>
        public void Launch(ThreadStart _callBack, string _actionName)
        {
            Thread th = new Thread(_callBack);
            th.IsBackground = true;
            th.Start();
            wdwWait frmWait = new wdwWait(_actionName);
            frmWait.Show();
            th.Join();
            frmWait.Close();
        }
    }

avec cette méthode, j'ai un gros carré blanc à la place de ma fenêtre wdwWait, avec un sablier et un fameux message "ne répond pas", en attedant la fin de de th.Join()...

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
 
/// <summary>
    /// classe gérant les appels au thread d'opérations longues
    /// </summary>
    public class ThreadManager
    {
        private static ThreadManager _instance = null;
        public static ThreadManager Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new ThreadManager();
                return _instance;
            }
        }
 
        private System.Timers.Timer t;
        private wdwWait frmWait;
        private Thread th;
 
        /// <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>
        public void Launch(ThreadStart _callBack, string _actionName)
        {
            th = new Thread(_callBack);
            th.IsBackground = true;
            th.Start();
 
            t = new System.Timers.Timer(500);
            t.Enabled = true;
            t.Elapsed += new System.Timers.ElapsedEventHandler(OnTimerTick);
 
            frmWait = new wdwWait(_actionName);
            frmWait.ShowDialog();
        }
 
        public void OnTimerTick(object o, System.Timers.ElapsedEventArgs e)
        {
            if (!th.IsAlive)
                frmWait.Close();
        }
    }

Avec cette option la, la fenêtre d'attente réagit bien, mais j'ai belle exception m'empêchant de fermer ma fenêtre à la fin du thread ("Le thread appelant ne peut pas accéder à cet objet parce qu'un autre thread en est propriétaire.")

Je suis bien bloqué là, merci pour toute aide :D

salut,
dans ton deuxième code essaie de faire un Abort du thread avant de fermer la Form

Code:

1
2
3
4
5
6
7
8
public void OnTimerTick(object o, System.Timers.ElapsedEventArgs e)
        {
            if (!th.IsAlive)
               {
                th.Abort()
                frmWait.Close();
                }
        }

01/06/2009, 17h18
tomlev

En WPF (comme en WinForms d'ailleurs), on ne peut accéder à l'interface graphique qu'à partir du thread qui l'a créée. Si un autre thread doit effectuer une opération sur l'interface graphique, il faut passer par le Dispatcher de l'interface (méthode Dispatcher.Invoke).

Ta première méthode avec le Join n'est pas adaptée puisqu'elle bloque le thread principal (qui met à jour l'interface graphique) jusqu'à la fin du thread de traitement : tu perds tout l'intérêt de faire le traitement dans un autre thread.

Ta 2e méthode pourrait marcher mais tu n'utilises pas le bon type de timer : System.Timers.Timer lève l'évènement Elapsed sur un thread du ThreadPool, et non sur celui de l'interface, d'où l'erreur quand tu essaies de fermer la fenêtre. Il faudrait plutôt utiliser un System.Windows.Threading.DispatcherTimer (spécifique à WPF).

Une autre solution, plus simple et plus propre à mon avis, serait d'utiliser un BackgroundWorker pour effectuer le traitement : ce composant effectue le traitement sur un autre thread, mais déclenche les évènements ProgressChanged et RunWorkerCompleted sur le thread qui a créé le BackgroundWorker (en général le thread d'interface).
01/06/2009, 17h31
thelpi

Merci infiniment !!! ça marche très bien avec la solution du DispatcherTimer. J'avais regardé la solution du BackGroundWorker mais j'avais pas bien saisi le fonctionnement (notamment à quel niveau on lui donne la méthode à exécuter).

J'avais une dernière question cependant : en windows form, on peut sans problème faire

Code:

maForm.Invoke(monDélégué)

en WPF, je ne trouve aucune méthode concernant Invoke... Normal?
01/06/2009, 17h42
tomlev

Citation:

Envoyé par thelpi

J'avais regardé la solution du BackGroundWorker mais j'avais pas bien saisi le fonctionnement (notamment à quel niveau on lui donne la méthode à exécuter).

Il suffit d'affecter un handler à l'évènement DoWork, dans lequel tu fais le traitement.

Citation:

Envoyé par thelpi

J'avais une dernière question cependant : en windows form, on peut sans problème faire

Code:

maForm.Invoke(monDélégué)

en WPF, je ne trouve aucune méthode concernant Invoke... Normal?

On n'appelle pas directement Invoke sur le contrôle, mais sur la propriété Dispatcher du contrôle.
01/06/2009, 17h59
thelpi

Ok, merci pour toutes ces précisions.
@plus