Discussion :

[Kilazur]

Bonjour bonjour!

Je me suis pris la tête là-dessus toute la journée, j'admets n'avoir jamais trop touché au multithreading, mais quand même je suis sur les fesses...

Mise en situation:
J'ai donc une Form qui effectue des opérations "lourdes" (connexion, chargement de données, etc). Je fais faire ces opérations par un thread créé sur le tas, et j'affiche un petit gif animé pendant ce temps-là. Sauf que j'ai à un moment donné deux appels d'affilée à ma fonction "fais une opération en fond", et comme je rend le gif (in)visible de façon thread safe asynchrone, il semble que ça ne suive pas et que mon gif reste invisible...

Mais comme des sources parlent mieux que des mots:

-Les fonctions générales

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
 
// Permet d'effectuer une modification thread-safe sur un contrôle
protected void addControlWork(Control c, Action a)
{
	if (c.InvokeRequired)
		c.BeginInvoke(new MethodInvoker(a));
	else
		a();
}
 
//Lance une tâche de fond, affiche le logo chargement, désactive les autres contrôles
protected void doWorkInBackground(MethodInvoker )
{
	addControlWork(loadingPicture, delegate() { loadingPicture.Visible = true; });
	addControlWork(mainPanel, delegate() { mainPanel.Enabled = false; });
	f.BeginInvoke(new AsyncCallback(endWorkInBackground), null);
}
 
//A la fin d'une tâche de fond, efface le logo chargement, active les autres contrôles
protected void endWorkInBackground(IAsyncResult result)
{
	if (this.Disposing)
		return;
	addControlWork(loadingPicture, delegate() { loadingPicture.Visible = false; });
	addControlWork(mainPanel, delegate() { mainPanel.Enabled = true; });
}

-L'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
24
25
26
27
 
private void uneListBox_SelectedIndexChanged(object sender, EventArgs e)
{
	doWorkInBackground((MethodInvoker)(() =>
	{
		object[] source = LongueOperation();;
		addControlWork(uneComboBox, delegate()
		{
			// Changing DataSource fires comboBox.SelectedIndexChanged
			uneComboBox.DataSource = source;
		});
	}));
}
 
private void uneComboBox_SelectedIndexChanged(object s, EventArgs e)
{
 
doWorkInBackground((MethodInvoker)(() =>
{
// Le code est pas intéressant ici
	object[] range = uneOperationLourde();
	object[] source = uneAutreOperationLourde();
	addControlWork(uneListBox, delegate() { uneListBox.Items.AddRange(range); });
	addControlWork(uneComboBox, delegate() { uneComboBox.DataSource = source; });
}));
 
}

Dans l'exemple ci-dessus, on peut voir que lorsque uneListBox_SelectedIndexChanged est appelé, uneComboBox_SelectedIndexChanged est appelé immédiatement après. Et c'est là que le bât blesse, mon pov' piti logo reste invisible, seul et abandonné dans les méandres de la mémoire de ma machine.

Je souhaite donc savoir si quelqu'un a une idée de ce qui cloche, de comment améliorer ça, ou tout simplement si quelqu'un peut me donner une meilleure marche à suivre (j'ai entendu parler des await en 4.5?)

Merci bien!

Edit: Evidemment j'ai des solutions pansements, du genre créer deux fonctions startLoading et stopLoading dans lesquelles je m'occupe de la visibilité du logo et de l'activation du panel, mais c'est pas forcément très intuitif.

Edit: Pour résumer, ma fonction de démarrage de tâche de fond qui rend visible le gif de chargement est à un moment appelée avant qu'une autre tâche de fond ne soit terminée. Donc cette dernière se termine juste après le démarrage de la suivante, rendant mon gif invisible pendant le traitement de celle-ci. Il y a un moyen de "queue" les tâches de fond?

[lead8209]

Salut,
que penses-tu de ç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
 
private void uneListBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            pictureBox1.Visible = true;
 
            Task.Factory.StartNew(() =>
                {
                    Thread.Sleep(5000);
                    //combobox.Datasource = .... chargement des données //peut-être qu'il faut un invoke sur la combobox comme ci-dessous mais je ne crois pas
 
                    pictureBox1.Invoke(new MethodInvoker(delegate //on cache la picture box lorsque le travail est terminé
                    {
                        pictureBox1.Visible = false;
                    }));
 
                });
        }

Je suis pas spécialiste en multi th mais je crois que c'est tes BeginInvoke qui !@#
J'ai pas cru voir de EndInvoke donc tu ne forces jamais le programme à fini ce qu'il droit faire dans le BeginInvoke(). Ça revient à dire : tient faudra faire ça quand t'as le temps. Mais si le thread principal se fini avant hein t'embête pas on oubli ^^
En gros.. mais je suis pas spécialiste et s'il faut rien à voir ^^

A+

[DonQuiche]

Bonjour/bonsoir.

Je vois le problème :
a) A la fin de ta première opération asynchrone (démarrée dans uneListBox_SelectedIndexChanged) tu as placé en file d'attente "uneComboBox.DataSource = ..." suivi de "loadingPicture.Visible = false".
b) Le premier élément est appelé, qui appelle à son tour "uneComboBox_SelectedIndexChanged" qui effectue immédiatement "loadingPicture.Visible = true" plutôt que de le mettre en file d'attente vu qu'on est sur le thread UI. Mais puisque la file d'attente contient toujours "loadingPicture.Visible = false", ce dernier appel l'emporte.


Voici une mise en oeuvre simple et correcte:

Code c# :

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
async void uneListBox_SelectedIndexChanged(object sender, EventArgs e)
{
    // Thread UI
    SuspendUI();
 
    // Arrière-plan
    object[] source = await Task.Run(LongueOperation);
 
    // Thread UI
    uneComboBox.DataSource = source;
    ResumeUI();
}
 
async void uneComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
    // Thread UI
    SuspendUI();
 
    // Arrière-plan (pour plus d''efficacité on pourrait les lancer en parallèle et attendre avec Task.WaitAll)
    object[] range = await Task.Run(uneOperationLourde);
    object[] source = await Task.Run(uneAutreOperationLourde);
 
    // Thread UI
    uneListBox.Items.AddRange(range);
    uneComboBox.DataSource = source;
    ResumeUI();
}
 
int suspensionCounter;
void SuspendUI()
{
    ++suspensionCounter;
    if (suspensionCounter != 1) return;
    loadingPicture.Visible = true;
    mainPanel.Enabled = false;
}
void ResumeUI()
{
    --suspensionCounter;
    if (suspensionCounter != 0) return;
    loadingPicture.Visible = false;
    mainPanel.Enabled = true;
}

[Kilazur]

Merci beaucoup pour les réponses j'ai eu le temps de me pencher sur le sujet, et malheureusement je n'ai pas accès à async/await dans mon environnement de travail!

Donc pour l'instant, j'ai juste remplacé les DataSource = truc par une fonction qui neutralise les events selectedIndexChanged, donc une opération à la fois. Ca marche mais c'est pas idéal quoi

J'ai pas cru voir de EndInvoke donc tu ne forces jamais le programme à fini ce qu'il droit faire dans le BeginInvoke()

En fait, c'est dans cette ligne:

Code :

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

f.BeginInvoke(new AsyncCallback(endWorkInBackground), null);

BeginInvoke qui demande une fonction callback quoi, appelée j'imagine dès que la fonction f est terminée, mais p'têt que j'me trompe

[DonQuiche]

Merci beaucoup pour les réponses j'ai eu le temps de me pencher sur le sujet, et malheureusement je n'ai pas accès à async/await dans mon environnement de travail!

Async/await aurait permis de simplifier le code mais la clé de la solution que j'avais proposée c'était SuspendUI/ResumeUI avec l'utilisation d'un compteur de suspension. Tu pourrais très bien utiliser cette solution avec ton code d'origine.

BeginInvoke qui demande une fonction callback quoi, appelée j'imagine dès que la fonction f est terminée, mais p'têt que j'me trompe

C'est tout à fait ça.

[Kilazur]

Async/await aurait permis de simplifier le code mais la clé de la solution que j'avais proposée c'était SuspendUI/ResumeUI avec l'utilisation d'un compteur de suspension. Tu pourrais très bien utiliser cette solution avec ton code d'origine.

J'ai tenté d'implémenter un truc du genre en vain, et c'était vraiment... sale
A base de compteur de nombres de tâches en fond et de création de thread qui contiennent juste une boucle while avant l'appel à la création d'une nouvelle tâche de fond... Bref, une horreur sans nom Et pis ça marchait pas

Et SuspendUI, ça ne va pas... ben, suspendre l'UI et mon gif qui va avec?