Discussion :

[Angelinsky7]

Bonjour,
J'ai une petite question sur les threads et les progress bar dans une fenêtre model.

Voila... mon but est de créer une fenêtre modal qui contient un progress bar que je pourrais réutiliser dans plusieurs cas différents de mon application... et de donner également la possibilité à d'autre de pas l'utiliser....

J'ai donc créer une interface qui me donne la possibité d'afficher une fenêtre puis de faire avancer la progress bar et ensuite de la fermer....

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ManagerLibs.Views {
	/// <summary>
	/// 
	/// </summary>
	public interface ILoading {
		void ShowWindow();
		void CloseWindow();
		void SetTitle(string title);
		void SetMaxTime(long max);
		void SetCurrentTime(long time);
	}
}

Ensuite j'implémente mon interface dans la fenêtre...

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
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace ManagerLibs.Views {
	public partial class LoadingForm : Form, ILoading {
 
		public LoadingForm() {
			InitializeComponent();
		}
 
		public void ShowWindow() {
			this.ShowDialog();
		}
 
		public void CloseWindow() {
			this.Close();
		}
 
		public void SetTitle(string title) {
			this.Text = title;
		}
 
		public void SetMaxTime(long max) {
			this.progressBar.Maximum = (int)max;
		}
 
		public void SetCurrentTime(long time) {
			this.progressBar.Value = (int)time;
		}
 
	}
}

Puis dans un contrôleur plus loin je créer cette fenêtre et la donne à un autre contrôleur (...)

Code :

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

1
2
3
4
CsvController csvController = CsvController.getInstance();
LoadingForm loadingForm = new LoadingForm();
List<CsvTable> table = (List<CsvTable>)csvController.LoadFile(loadingForm, dialog.FileName);
dataGridCSV.DataSource = table;

Et enfin le code du dernier contrôleur

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
public IEnumerable LoadFile(ILoading progress, String file) {
			m_ProgressBar = progress;
			m_File = file;
 
			m_TotalNumberOfLine = this.CoutLinesInFile();
			m_ProgressBar.SetMaxTime(m_TotalNumberOfLine);
 
			m_Table = new List<CsvTable>();
 
			m_Worker = new Thread(this.ReadFile);
			try {
				m_Worker.IsBackground = true;
				m_Worker.Start();
 
				m_ProgressBar.SetTitle("Reading CSV File...");
				m_ProgressBar.ShowWindow();
 
				m_Worker.Join();
			}
			catch (Exception e) {
				throw new Exception(e.Message);
			}
 
			return m_Table;
		}

et le code qui prend du temps (la raison pour laquelle je fais un thread)

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
private void ReadFile() {
			try {
				var csvFile = File.ReadAllLines(@m_File);
 
				var currentTime = 0;
				foreach (String row in csvFile) {
					var formatedRow = row.Split(m_Delimiter);
					CsvTable temp = new CsvTable();
 
					temp.id = formatedRow[0];
					temp.value1 = formatedRow[1];
					temp.value2 = formatedRow[2];
					temp.value3 = formatedRow[3];
					temp.value4 = formatedRow[4];
 
					((List<CsvTable>)m_Table).Add(temp);
 
					m_ProgressBar.SetCurrentTime(currentTime++);
 
				}
				Thread.Sleep(100);
				m_ProgressBar.CloseWindow();
			}
			catch (Exception exception) {
				System.Windows.Forms.MessageBox.Show(exception.Message.ToString());
			}
 
		}

Voila voila alors je sais tout le monde me conseil le fameux backgroundWorker mais je ne trouve pas cette solution intéressante car je dois mettre le code de mon contrôleur dans la fenêtre et créer une fenêtre abstraite que je pourrais etendre pour chaque contrôleur ne m'intéresse pas non plus (dans le cas ou je voudrais utiliser cette même fenêtre de progression dans plusieurs contrôleurs différents)

Je sais également que je devrais utiliser le Invoke mais lui aussi ne me plait pas car je suis obligé de passer tout ma fenêtre et non plus simplement l'interface à mon contrôleur... ou alors en faisant des magouilles)

Enfin voila pour la situation mais maintenant le plus intéressant :
Tout fonctionne très bien !!!! Enfin presque si j'exécute l'exe builder mon code fonctionne parfaitement bien.... et là je me dis que c'est déjà pas mal... par contre chose étonnant c'est dans le débugger que j'ai des exceptions... sur le faite bien entendu d'accéder à un contrôle d'une fenêtre depuis un autre thread.... du coup ma question pourquoi ça ne fonctionne en mode debug... ou alors pourquoi est-ce que cela fonctionne que je lance l'appli en exe alors que tout devrait porter à croire que mon appli devrai me renvoyer une exception ???!!!

Désolé pour la pavé mais comme ça du coup si quelqu'un à la patience de me lire et la gentillesse de pouvoir me conseiller ça serait vraiment parfait....

Merci d'avance à toutes les personnes qui pourraient m'aider...

Angle

[StormimOn]

Ajoute des invoke afin d'éviter les méchants appels inter-threads. Par exemple ainsi

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 void CloseWindow()
{
    InvokeMethod(delegate
    {
        this.Close();
    });
}
 
public void SetCurrentTime(long time)
{
    InvokeMethod(delegate
    {
        this.progressBar.Value = (int)time;
    });
}
 
private void InvokeMethod(MethodInvoker mi)
{
    if (this.InvokeRequired)
    {
        this.Invoke(mi);
    }
    else
    {
        mi();
    }
}

Sinon la ligne

Code :

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

m_Worker.Join();

ne sert à rien puisque la fenêtre est affichée en modal. Tu n'arriveras sur cette ligne que lorsque tu fermeras la fenêtre. Le thread aura alors fini son boulot et le Join ne sert donc pas.

[tomlev]

Je vois une méthode beaucoup plus simple d'arriver au même résultat...
Ca utilise un BackgroundWorker... je sais, t'en veux pas mais quand tu verras ma solution je pense que tu n'y verras plus d'inconvénient

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
    public partial class ProgressDialog : Form
    {
        public ProgressDialog()
        {
            InitializeComponent();
        }
 
        private Action<Action<int>> _action;
 
        public DialogResult ExecuteModal(Action<Action<int>> action)
        {
            if (action == null)
                throw new ArgumentNullException("action");
            _action = action;
            progressBar.Value = 0;
            this.Exception = null;
            backgroundWorker.RunWorkerAsync();
            return this.ShowDialog();
        }
 
        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            _action(backgroundWorker.ReportProgress);
        }
 
        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            progressBar.Value = e.ProgressPercentage;
        }
 
        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                this.Exception = e.Error;
                this.DialogResult = DialogResult.Abort;
            }
            else
            {
                progressBar.Value = 100;
                this.DialogResult = DialogResult.OK;
            }
            this.Close();
        }
 
        public Exception Exception { get; private set; }
    }

La méthode ExecuteModal prend en paramètre un delegate qui représente ton traitement, qui lui même accepte en paramètre un delegate qui prend en paramètre un int (la méthode pour indiquer la progression). Ca parait compliqué comme ça, mais en fait c'est très simple, voilà un exemple d'utilisation :

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
        private void button1_Click(object sender, EventArgs e)
        {
            ProgressDialog dlg = new ProgressDialog();
            DialogResult result = dlg.ExecuteModal(
                (reportProgress) =>
                {
                    // évidemment en pratique il vaudrait mieux que
                    // ce soit un traitement plus utile que ça ;)
                    for (int i = 0; i < 100; i++)
                    {
                        Thread.Sleep(100);
                        reportProgress(i);
                    }
                });
 
            if (result == DialogResult.OK)
                MessageBox.Show("OK");
            else
                MessageBox.Show("Erreur : " + dlg.Exception);
        }

J'ai utilisé une expression lambda pour définir le traitement, mais si tu n'es pas à l'aise avec ça tu peux toujours le définir dans une autre méthode :

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
        private void button1_Click(object sender, EventArgs e)
        {
            ProgressDialog dlg = new ProgressDialog();
            DialogResult result = dlg.ExecuteModal(Traitement);
 
            if (result == DialogResult.OK)
                MessageBox.Show("OK");
            else
                MessageBox.Show("Erreur : " + dlg.Exception);
        }
 
        private void Traitement(Action<int> reportProgress)
        {
            for (int i = 0; i < 100; i++)
            {
                Thread.Sleep(100);
                reportProgress(i);
            }
        }

Cette technique permet de bien séparer les responsabilités : le ProgressDialog ne gère que la progression du traitement, et le traitement lui-même est défini là où tu en as besoin...

[Angelinsky7]

Bonjour,
Tout d'abord merci pour les réponses et propositions....

La solution de "tomlev" est pas mal... je pense que si je n'arrive pas à faire ce que je veux j'utiliserai cette méthode... mais (oui je suis désolé) je trouve quant même un peu dérangeant d'envoyer le code à exécute à la fenêtre... (si j'ai bien compris, tu lui donne le code en paramètre au final) ca crée un template de fenêtre qui permet d'exécuter n'importe quel code dans cette progress Window.... mais reste que c'est quant même le fenêtre qui l'exécute au runtime... alors que .... non ???

Enfin c'est une belle solution que je vais sûrement utiliser au final....

Pour l'instant je suis encore sur la piste de "Invoke" il semblerait que ca puisse résoudre mon problème d'exception... si tu as une piste.... avec plaisir....

Merci encore pour toute l'aide proposée....

Angle

[Angelinsky7]

Bonjour tout le monde,

Voici la solution que j'ai trouvée et qui me plait....

Une Interface :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
 
namespace ProgressBarLibs {
	/// <summary>
	/// 
	/// </summary>
	public interface ILoading {
		void ShowWindow();
		void CloseWindow();
		void SetTitle(String title);
		void SetProgressBarMax(int max);
		void SetProgressBarCurrent(int current);
	}
}

La fenêtre qui l'implémente :

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
using System;
using System.Windows.Forms;
 
namespace ProgressBarLibs {
	public partial class LoadingForm : Form, ILoading {
 
		/// <summary>
		/// The Delegate Method Type
		/// </summary>
		private delegate void DelegateVoid();
		private delegate void DelegateString(String s);
		private delegate void DelegateInt(int l);
 
		/// <summary>
		/// The Delegate Methods
		/// </summary>
		private DelegateVoid m_ShowWindowDelegate = null;
		private DelegateVoid m_CloseWindowDelegate = null;
		private DelegateString m_SetTitleDelegate = null;
		private DelegateInt m_SetProgressBarMaxDelegate = null;
		private DelegateInt m_SetProgressBarCurrentDelegate = null;
 
		/*private DateTime m_StartTime;
		private DateTime m_EndTime;
		private double m_TotalTime;*/
 
		/// <summary>
		/// The Constructor
		/// </summary>
		public LoadingForm() {
			InitializeComponent();
 
			m_ShowWindowDelegate = new DelegateVoid(ShowWindowDelegate);
			m_CloseWindowDelegate = new DelegateVoid(CloseWindowDelegate);
			m_SetTitleDelegate = new DelegateString(SetTitleDelegate);
			m_SetProgressBarMaxDelegate = new DelegateInt(SetProgressBarMaxDelegate);
			m_SetProgressBarCurrentDelegate = new DelegateInt(SetProgressBarCurrentDelegate);
		}
 
		/// <summary>
		/// The Show Window Delegate Method
		/// </summary>
		private void ShowWindowDelegate() {
			this.ShowDialog();
		}
 
		/// <summary>
		/// The Close Window Delegate Method
		/// </summary>
		private void CloseWindowDelegate() {
			this.Close();
		}
 
		/// <summary>
		/// The Set Title Delegate Method
		/// </summary>
		/// <param name="title"></param>
		private void SetTitleDelegate(String title) {
			Text = title;
		}
 
		/// <summary>
		/// The Set Progress Bar max Delegate Method
		/// </summary>
		/// <param name="max"></param>
		private void SetProgressBarMaxDelegate(int max) {
			progressBar.Maximum = max;
		}
 
		/// <summary>
		/// The Set Progress Bar Current Delegate Method
		/// </summary>
		/// <param name="max"></param>
		private void SetProgressBarCurrentDelegate(int current) {
			progressBar.Value = current;
		}
 
		/// <summary>
		/// The Show Window Method
		/// </summary>
		public void ShowWindow() {
			if (InvokeRequired) {
				Invoke(m_ShowWindowDelegate);
			}
			else {
				ShowWindowDelegate();
			}
		}
 
		/// <summary>
		/// The Close Window Method
		/// Pay Attendion to put a Thread.Sleep(100); after the call to the Close if the current processing may be fast
		/// </summary>
		public void CloseWindow() {
			if (InvokeRequired) {
				Invoke(m_CloseWindowDelegate);
			}
			else {
				CloseWindowDelegate();
			}
		}
 
		/// <summary>
		/// The Set Title Method
		/// </summary>
		/// <param name="title"></param>
		public void SetTitle(String title) {
			if (InvokeRequired) {
				Invoke(m_SetTitleDelegate, new Object[]{title});
			}
			else {
				SetTitleDelegate(title);
			}
		}
 
		/// <summary>
		/// The Set Progress Bar Max Method
		/// </summary>
		/// <param name="max"></param>
		public void SetProgressBarMax(int max) {
			if (InvokeRequired) {
				Invoke(m_SetProgressBarMaxDelegate, new Object[] { max });
			}
			else {
				SetProgressBarMaxDelegate(max);
			}
		}
 
		/// <summary>
		/// The Set Progress Bar Current Method
		/// </summary>
		/// <param name="max"></param>
		public void SetProgressBarCurrent(int current) {
			if (InvokeRequired) {
				Invoke(m_SetProgressBarCurrentDelegate, new Object[] { current });
			}
			else {
				SetProgressBarCurrentDelegate(current);
			}
		}
	}
}

Notez les delegates, les appels à Invoke et les vérifications que c'est réellement nécessaire d'utiliser un invoke comme conseiller par http://www.discretevector.com/2008/0...ike-magic.html....

Et un exemple d'utilisation :

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
public void LoadFile(ILoading progress, String file) {
			m_ProgressBar = progress;
			m_File = file;
 
			m_TotalNumberOfLine = this.CoutLinesInFile();
			m_ProgressBar.SetProgressBarMax(m_TotalNumberOfLine);
 
			m_Table = new List<CsvTable>();
 
			m_Worker = new Thread(this.ReadFile);
			try {
				m_Worker.IsBackground = true;
				m_Worker.Start();
 
				m_ProgressBar.SetTitle("Reading CSV File...");
				m_ProgressBar.ShowWindow();
 
				m_Worker.Join();
			}
			catch (Exception e) {
				throw new Exception(e.Message);
			}
		}

Avec le code du thread qui utilise aussi l'interface

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
/// <summary>
		/// 
		/// </summary>
		/// <param name="file"></param>
		/// <returns></returns>
		private void ReadFile() {
			try {
				var csvFile = File.ReadAllLines(@m_File);
 
				var currentTime = 1;
				foreach (String row in csvFile) {
					var formatedRow = row.Split(m_Delimiter);
					CsvTable temp = new CsvTable();
 
					//temp.id = formatedRow[0];
					temp.value1 = formatedRow[1];
					temp.value2 = formatedRow[2];
					temp.value3 = formatedRow[3];
					temp.value4 = formatedRow[4];
 
					((List<CsvTable>)m_Table).Add(temp);
 
					m_ProgressBar.SetProgressBarCurrent(currentTime++);
				}
				Thread.Sleep(100);
				m_ProgressBar.CloseWindow();
			}
			catch (Exception exception) {
				System.Windows.Forms.MessageBox.Show(exception.Message.ToString());
			}
 
		}

Notez ici également une petite astuce juste avant la fermeture de la fenêtre le Thread.sleep(100) qui s'assure que rien ne plante si le traitement était très rapide... car si le traitement est trop rapide le handle de la fenêtre n'a pas le temps de s'instancier et du coup sa plante.... du coup c'est un peu moche (oui je pourrais aussi mettre ca dans la fenêtre mais du coup je me disais que ce n'était pas particulièrement gênant de faire une pause dans un thread...)

Voila... merci à tout le monde pour vos conseil... si quelqu'un veut laisser un commentaire afin de critiquer ou de proposer des améliorations de ce code, je vous en prie....

A bientot

Angle

P.S. Je laisse ce post ouvert encore un moment au cas ou quelqu'un voudrait rajouter un commentaire... je le fermerai dans quelques jours....

[tomlev]

mais reste que c'est quant même le fenêtre qui l'exécute au runtime... alors que .... non ???

Et alors ? je vois pas en quoi c'est un problème... C'est juste que le traitement est appelé à partir du ProgressDialog, mais au final ça change rien...

Notez ici également une petite astuce juste avant la fermeture de la fenêtre le Thread.sleep(100) qui s'assure que rien ne plante si le traitement était très rapide... car si le traitement est trop rapide le handle de la fenêtre n'a pas le temps de s'instancier et du coup sa plante.... du coup c'est un peu moche (oui je pourrais aussi mettre ca dans la fenêtre mais du coup je me disais que ce n'était pas particulièrement gênant de faire une pause dans un thread...)

C'est un peu du bricolage... Tu peux toujours forcer la création du handle : il suffit d'accéder à la propriété Handle, et ça le crée s'il n'est pas encore créé.

Bref, je trouvais ma solution plus simple, mais c'est à toi de voir

P.S. Je laisse ce post ouvert encore un moment au cas ou quelqu'un voudrait rajouter un commentaire... je le fermerai dans quelques jours....

Tu peux le marquer comme résolu, ça n'empêche pas de continuer la discussion

[StormimOn]

Notez les delegates, les appels à Invoke et les vérifications que c'est réellement nécessaire d'utiliser un invoke

Tu te prends bien la tête de la façon dont tu procèdes. Si tu regardes ma façon de faire c'est bien plus simple (pas besoin de créer les différentes délégation notamment). Je passe par une méthode anonyme, technique à laquelle tu devrais avoir accès aussi puisque tu mentionnes le BackgroundWorker (composant apparu avec le Framework 2.0, tout comme les méthodes anonymes).

Ensuite tu utilises l'invoke sur toutes tes méthodes alors que seulement certaines sont concernées (celles appelées depuis le thread du traitement, à savoir SetProgressBarCurrent et CloseWindow).

Et pour finir, tu as toujours le

Code :

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

m_Worker.Join();

qui ne sert à rien à mon avis. A moins que tu ais vérifié qu'il serve, mais j'ai un doute.

[Angelinsky7]

Bonjour

Le thread.join est la car je récupère plus loin le résultat de cette requete... (... pas très explicite je sais mais bon il est la car je suis obligé....)

Et merci pour l'info sur les Handle je vais directement modifier mon code ca sera beaucoup mieux... (oui en effet, je trouvait ca degueux aussi....)

Merci pour tout, je sais que c'est une solution qui pour beaucoup semble plus compliquée et surement inutile mais bon.... mon esprit tordu m'empeche de coder ca autrement...

A+

Angle