Discussion :

[petitours]

Bonjour

Si j’exécute ceci

Code :

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

1
2
3
4
5
6
7
8
Stopwatch TimeWatch = new Stopwatch();        
TimeWatch.Reset();                      
TimeWatch.Start();                             
 
await untrucLongAsync()
 
TimeWatch.Stop(); // arret du chronometre
label_Status.Text += TimeWatch.ElapsedMilliseconds.ToString()

j'ai bien mon label qui se met à jour à la fin du await

Mais si je fais ceci

Code :

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

1
2
3
4
5
6
7
8
9
Stopwatch TimeWatch = new Stopwatch();        
TimeWatch.Reset();                      
TimeWatch.Start();                             
 
await untrucLongAsync();
await unAutreTrucAsyncQuiDoitSeFaireApreslepremier();
 
TimeWatch.Stop(); 
label_Status.Text += TimeWatch.ElapsedMilliseconds.ToString()

untrucLongAsync et unAutreTrucAsyncQuiDoitSeFaireApreslepremier s’exécutent en même temps

J'en suis sur parce que les 2 vont lire les m^mes fichiers et forcément ça fait des étincelles

Les 2 fonctions async utilisent une List<Task> et await Task.WhenAll

Pourriez vous m’aiguiller sur ce qui empêche le second await d'attendre que le premier ait terminé ?

Merci par avance

[OrcusZ]

Peut-tu poster l'implémentation de tes deux méthodes ?

[petitours]

Bonjour

A ce stade l’essai de lancer 2 fois la même chose , une fois après l'autre

la fonction await (untrucLongAsync ou unAutreTrucAsyncQuiDoitSeFaireApreslepremier donc)

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
 
// Creation de la liste de tache parrallélisées
List<Task> parallelTasks = new List<Task>();
 
ctsTemporel = new CancellationTokenSource();  // pour l'annulation des tâches parallèlles
try
{
	foreach (Parametre Param in Metier.LstParametresSelected)
	{
        	/*
		Un peu de preparation
		*/
 
 
                //Création d'un objet qui recherche et calcule en asynchrone les points necessaires à la série
                Temporel MaTemporel = new Temporel(param1,param2,param3);
 
		parallelTasks.Add(MaTemporel.CalculAsync(Param, progressIndicator, ctsTemporel.Token).ContinueWith(tsk =>
                { 
                	ctsTemporel.Token.ThrowIfCancellationRequested(); // Annulation si demandé 
 
                        /*
			De la mise en forme du resultat obtenu			
			*/
 
    		}, TaskScheduler.FromCurrentSynchronizationContext()));
 
      	} // fin du foreach parametre
 
	await Task.WhenAll(parallelTasks);
 }
catch (OperationCanceledException)
{
	label_Avancement.Text = "Génération des courbes annulée !";
 
	Menage(); 
 
	return;
}
catch (Exception ex)
{
	richTextBox1.Text += "\r\nErreur pendant la génération  ! : \r\n" + ex.ToString();
 
	Menage(); 
	return;
}

et le Temporel.CalculAsync :

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
public Task CalculAsync(Parametre Param, IProgress<String> progress, CancellationToken CancelToken)
{
 
	return Task.Run(() =>
	{
                foreach (FichierPar F in Param.ListFichiersChargesCroissants)
                { 
 
                    progress.Report(Task.CurrentId.ToString() + ";10");
 
                    using (BinaryReader MonReader = new BinaryReader(File.Open(F.CheminPar, FileMode.Open)))
                    {
                        MonReader.BaseStream.Position = 0;  
 
 
                        if (progress != null)
                        {
                            while (MonReader.BaseStream.Position < FinLecture)
                            {
                                //lecture du fichier
                               /* remplissage d'un tableau
				*/
 
                            } 
 
 
                            CancelToken.ThrowIfCancellationRequested();   // Annulation si demandée par ailleurs
                        }
 
 
                    }//fin du using fichier
 
                }
 
                progress.Report(Task.CurrentId.ToString() + ";100");
 
	}, CancelToken);
 
}

[François DORIN]

J'en suis sur parce que les 2 vont lire les m^mes fichiers et forcément ça fait des étincelles

Pour ma part, je suis sur que les deux ne s'exécutent pas en même temps, car l'utilisation de async/await depuis le thread graphique ne fait qu'introduire de l'asymchronisme, pas du parallélisme

Je parie plutôt sur une mauvaise libération des ressources au niveau de la fonction untrucLongAsync. Peut-on voir son code ? Je viens de voir que c'était disponible

[edit]
Je n'ai pas vu d'erreur dans le code. Il eut toujours y avoir des petites surprises avec les fichiers. Des fois, la cause ce n'est pas forcément le code, mais un antivirus ! Analyse en temps réel -> bing. Attendre quelques ms peut permettre d'éviter le problème

Si tu n'as besoin que des accès en lecture, je te conseille d'ouvrir les fichiers en lecture seule, qui autorise plusieurs accès concurrents tant que le fichier n'est pas ouvert en écriture par un autre process.
[/EDIT]

[petitours]

Bonjour

Je passe tout ça en lecture seule... en effet c'est bien plus propre vu que je n'ai pas à écrire dedans !

j'ai aussi dégroupé le lancement des taches de la définition des "continueWith". C'est moins compact mais nettement plus lisible pour moi

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
 //ajout de la tache de traitement
                    Task Task_Traitement = MaTemporel.CalculAsync(Param, progressIndicator, ctsTemporel.Token);
                    parallelTasks.Add(Task_Traitement); //ajout à la liste de taches qui seront attendues par le WhenAll
 
                    //creation de la tache de continuité
                    Task Task_Continuation = Task_Traitement.ContinueWith(tsk =>
                    { // Remplissage de la série
                        ctsTemporel.Token.ThrowIfCancellationRequested(); // Annulation si demandée par ailleurs
 
                        /*trucs à faire après le traitement */
 
 
                    }, TaskScheduler.FromCurrentSynchronizationContext());
 
                    //ajout à la liste de taches qui seront attendues par le WhenAll
                    parallelTasks.Add(Task_Continuation);
 
                } // fin du foreach parametre
 
                await Task.WhenAll(parallelTasks) ;

J'ai fait ce code il y a 2 ans et j'ai mis un grand moment à re-percuter que le continueWith crée aussi des taches à attendre.

Merci