Discussion :

[Lorenzo77]

salut !

je viens de finir la partie difficile de mon petit projet, c'est un client FTP multi-Thread ou chaque Thread peut envoyer un fichier vers un FTP ...
plutot que d'avoir un Thread qui contrôle les autres Thread j'ai utilisé un Timer ce qui m'a énormément facilité la mise en place de cette partie "difficile" !

maintenant il reste un problème :
j'aimerais que chaque Thread puisse créer une ProgressBar dans un formulaire prévu a cette effet et met a jour la ProgressBar avec le pourcentage du fichier envoyé ... sauf qu'a la création de ma ProgressBar dans le 1er Thread j'ai cette erreur :

Les contrôles créés sur un thread ne peuvent pas être parents d'un contrôle d'un autre thread.

je ne vois pas quoi faire, vous avez une idée ?
merci

[ArianeV]

Bonjour,

Il me semble que les règles d'action d'un thread sur une form sont très strictes.

En gros, si tu as dans une meme form n ProgressBar et que tu veux que chacun d'entre eux soit controlé par un thread séparé (je crois que c'est ce que tu veux faire) tu dois passer par des délégués que tu appelles depuis tes threads.

En gros chaque thread possède un délégué sur une méthode de la form qui permet de mettre à jour l'état des ProgressBar. Ensuite il ne te reste plus qu'à pouvoir identifier quelle ProgressBar tu veux updater quand tu appelles la méthode (mais ce n'est pas bien compliqué).

Voila, j'espère que ça répond à ta question.

[StormimOn]

Seul le thread principal de l'application peut accéder à la partie graphique (thread de l'UI). Les autres threads n'ont pas le droit de toucher à ça, verboten

Pour faire ce que tu veux il faut passer par l'invocation. Les méthodes de ton formulaire ressembleront à ça, au prototype de la méthode près évidemment

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public delegate void MaMethodeCallBack();
public void MaMethode()
{
    // this représente un contrôle (Form, UserControl, ...)
    if (this.InvokeRequired)
    {
        this.Invoke(new MaMethodeCallBack(MaMethode));
    }
    else
    {
       // Traitement ici
    }
}

Tu peux maintenant appeler MaMethode depuis n'importe quel thread sans aucun risque.

[Lorenzo77]

merci les gars !
je suis bon pour reprogrammer toute la partie Thread de l'application
c'est justement cette partie qui m'a demandé le plus d'efforts

pas grave, ca me forcera a faire quelque chose de propre car pour l'instant j'oserais même pas la montrer alors que toute cette appli est censé finir sur sourceforge ou googlecode

[tomlev]

Une autre méthode, un peu plus simple, est d'utiliser des BackgroundWorker (BGW) à la place des threads. Dans l'évènement DoWork du BGW, tu fais le traitement, et tu appelles régulièrement ReportProgress, ce qui déclenche l'évènement ProgressChanged. Comme cet évènement est généré sur le thread de l'UI (du moins, sur le thread qui a démarré le BGW), tu peux mettre à jour tes progressbars dans le handler de cet évènement. Le BGW gère aussi l'annulation. Ca donne quelque chose comme ça :

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
 
// Exécuté sur le thread de l'UI
public void DémarrerTache()
{
    BackgroundWorker bgw = new BackgroundWorker();
    bgw.WorkerSupportsCancellation = true;
    bgw.WorkerReportsProgress = true;
    bgw.DoWork += bgw_DoWork;
    bgw.ProgressChanged += bgw_ProgressChanged;
    bgw.RunWorkerCompleted += bgw_RunWorkerCompleted;
    bgw.RunWorkerAsync();
}
 
// Exécuté sur un autre thread
private void bgw_DoWork(object sender, DoWorkEventArgs e)
{
    while(!bgw.CancellationPending && traitementPasFini)
    {
        // traitement
        ...
        bgw.ReportProgress(10); // 10%
        ...
        bgw.ReportProgress(20); // 20%
        ...
        // L'exception sera récupérée dans l'évènement  RunWorkerCompleted
        if (probleme) throw new Exception("oups");
        ...
    }
    e.Cancel = bgw.CancellationPending;
    e.Result = le_resultat_du_traitement;
}
 
// Exécuté sur le thread de l'UI
private void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progBar.Value = e.ProgressPercentage;
}
 
// Exécuté sur le thread de l'UI
private void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null) // Si une exception s'est produite dans DoWork
    {
        MessageBox.Show("Une erreur s'est produite : " + e.Error.Message);
    }
    else if (e.Cancelled)
    {
        MessageBox.Show("Le traitement a été annulé");
    }
    else
    {
        MessageBox.Show("Traitement terminé ! Résultat : " + e.Result);
    }
}

[Lorenzo77]

je viens de lire la DOC concernant la classe BackgroundWorker et elle a vraiment l'air beaucoup plus simple que les Thread.

je vais faire des tests, merci

[Lorenzo77]

salut,


j'ai fait un projet de test avec vos remarques.
je tombe toujours sur le même problème pourtant j'ai utilisé un délégué + event pour l'éviter :

Opération inter-threads non valide : le contrôle 'dataGridView1' a fait l'objet d'un accès à partir d'un thread autre que celui sur lequel il a été créé.

je suis obligé de laisser CheckForIllegalCrossThreadCalls = false; pour éviter cette erreur.

vous pouvez me dire si j'ai bien utilisé ce qu'il fallait, la ou il le fallait ?
et de la bonne manière ?

merci


le projet VS2008 complet (20Ko)

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
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;
 
 
namespace test_BackgroundWorker
{
 
 
    public partial class Form1 : Form
    {
        private int _indexBw = 0;
        private List<object> listBw;
 
 
 
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            //CheckForIllegalCrossThreadCalls = false;
            listBw = new List<object>();
        }
 
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // faudrait une tempo plutot que de bloquer la fermeture s'il reste des "bw.IsBusy" en attendant qu'ils soient fermés ..
            for (int i = 0; i < listBw.Count; i++) {
                BackgroundWorker bw = listBw[i] as BackgroundWorker;
                if (bw.IsBusy == true) {
                    (listBw[i] as BackgroundWorker).CancelAsync();
                    e.Cancel = true;
                }
            }
        }
 
        private void LancerProcessLong_Click(object sender, EventArgs e)
        {
            ProcessLong proc = new ProcessLong();
            ProcessLong.form = this;
            proc.idBw = _indexBw++;
            proc.eventCreaLigne += new ProcessLong.creaLigneHandler(proc_eventCreaLigne);
            proc.eventMajLigne += new ProcessLong.majLigneHandler(proc_eventMajLigne);
            toolStripTextBox1.Text = _indexBw.ToString();
 
            BackgroundWorker bw = new BackgroundWorker();
            listBw.Add(bw);
            bw.WorkerReportsProgress = true;
            bw.WorkerSupportsCancellation = true;
            bw.DoWork += new DoWorkEventHandler(proc.procDoWork);
            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(proc.procComplet);
            bw.ProgressChanged += new ProgressChangedEventHandler(proc.procProgressChange);
            bw.RunWorkerAsync();
        }
 
        private void AnnulerPremier_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < listBw.Count; i++) {
                BackgroundWorker bw = listBw[i] as BackgroundWorker;
                if (bw.IsBusy == true) {
                    (listBw[i] as BackgroundWorker).CancelAsync();
                    break;
                }
            }
        }
 
        private void AnnulerDernier_Click(object sender, EventArgs e)
        {
            (listBw[(listBw.Count - 1)] as BackgroundWorker).CancelAsync();
            for (int i = listBw.Count - 1; i >= 0; i--) {
                BackgroundWorker bw = listBw[i] as BackgroundWorker;
                if (bw.IsBusy == true) {
                    (listBw[i] as BackgroundWorker).CancelAsync();
                    break;
                }
            }
        }
 
        private void StopperTout_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < listBw.Count; i++) {
                BackgroundWorker bw = listBw[i] as BackgroundWorker;
                if (bw.IsBusy == true) {
                    (listBw[i] as BackgroundWorker).CancelAsync();
                }
            }
        }
 
 
 
        private void proc_eventMajLigne(object sender, int indexLigne, object chaine)
        {
            dataGridView1[0, indexLigne].Value = chaine;
        }
 
        private int proc_eventCreaLigne(object sender, object chaine)
        {
            return dataGridView1.Rows.Add(chaine);
        }
    }
 
 
 
 
    public class ProcessLong
    {
        public delegate int creaLigneHandler(object sender, object chaine);
        public delegate void majLigneHandler(object sender, int indexLigne, object chaine);
 
        public event creaLigneHandler eventCreaLigne;
        public event majLigneHandler eventMajLigne;
 
 
 
        // valeur a incrémenter
        private int _valeur = 0;
 
        // ID BackgroundWorker
        private int _idBw;
        public int idBw { get { return _idBw; } set { _idBw = value; } }
 
        // formulaire parent -> obliger d'utiliser une référence pour y accéder ?
        private static Form1 _form;
        public static Form1 form { get { return _form; } set { _form = value; } }
 
        // index DataGrid pour ce BackgroundWorker
        private int _indexDtg;
        public int indexDtg { get { return _indexDtg; } set { _indexDtg = value; } }
 
 
 
 
        public void procDoWork(object sender, DoWorkEventArgs e)
        {
            //Console.WriteLine("work debut{0} : {1}", this._idBw, this._valeur);
            _indexDtg = this.eventCreaLigne(this, "work debut(" + _idBw.ToString() + ") : " + _valeur.ToString());
            BackgroundWorker worker = sender as BackgroundWorker;
            while (worker.CancellationPending == false && _valeur < 5000) {
                Thread.Sleep(1);
                worker.ReportProgress(_valeur);
                _valeur++;
            }
        }
 
        public void procComplet(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null) {
                //Console.WriteLine("work ERREUR{0} : {1}", this._idBw, this._valeur);
                this.eventMajLigne(this, _indexDtg, "work ERREUR(" + _idBw.ToString() + ") : " + _valeur.ToString());
            }
            else if (e.Cancelled == true) {
                //Console.WriteLine("work ANNULÉ{0} : {1}", this._idBw, this._valeur);
                this.eventMajLigne(this, _indexDtg, "work ANNULÉ(" + _idBw.ToString() + ") : " + _valeur.ToString());
            }
            else {
                //Console.WriteLine("work fini{0} : {1}", this._idBw, this._valeur);
                this.eventMajLigne(this, _indexDtg, "work FINI(" + _idBw.ToString() + ") : " + _valeur.ToString());
            }
        }
 
        public void procProgressChange(object sender, ProgressChangedEventArgs e){
            //Console.WriteLine("work en cours{0} : {1}", this._idBw, this._valeur);
            this.eventMajLigne(this, _indexDtg, "work en cours(" + _idBw.ToString() + ") : " + _valeur.ToString());
        }
    }
}