Discussion :

[daerlnaxe]

Bonjour,

Ca me tarabuste car je me dis que ça doit être simplifiable mais je cale, j'essaie de faire de l'async mais comme je débute...


Cahier des charges, je lance une fonction quipeut prendre du temps, elle liste le contenu de répertoires surveillés, j'ai opté pour lancer des tâches en asynchrone pour gagner du temps (ce qui fonctionne bien avec ce code).

J'ai besoin d'attendre le résultat de ces tâches afin de lancer un processus commun de traitement par la suite et d'affecter le contenu dans une liste de classe etc... Si je colle le résult dans la première boucle, même avec un await ça attend, j'ai mis un chrono, plus des affichages, on voit bien que c'est dans l'ordre. J'ai un peu tripatouiller dans tous les sens, sans pour autant trouver au final une syntaxe efficace mais plus simple, je suis sur d'avoir lu à un moment une autre façon de faire mais je ne retrouve plus mes sources (je ne parle pas de convertir en Task.Run directement mais plutot de ne pas passer par deux boucles)

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
 
 
            var arrayTask = new Task<List<WatchedFile>>[listeDirs.Count];
 
            for (int i=0; i < listeDirs.Count; i++)
            {
                string dir = listeDirs[i];
                Task<List<WatchedFile>> t = new Task<List<WatchedFile>>(() => MakeListeDir(dir) );
 
                arrayTask[i] = t;
                t.Start();
 
            }
 
            for( int i =0; i < listeDirs.Count; i++ )
            {
 
                arrayTask[i].Wait();
                newListe[i].ListeFichiers = arrayTask[i].Result;
 
            }

Désolé j'espère ne pas abuser.

Merci.

[Pol63]

je ne suis pas expert en task, mais j'ai cru comprendre que ce n'était pas forcément exécuté sur un autre thread, mais parfois ca se partage un seul thread
essaye en démarrant des threads, puis en faisant des .join pour les attendre, là ca sera forcément tous en même temps (sachant que pour des accès disques prononcés (hors ssd) ce n'est pas toujours une bonne idée, il y a parfois un nombre de threads à ne pas dépasser)
(le threadpool permet de limiter à n threads à la fois)

[François DORIN]

Bonjour,

Je verrais bien 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
 
var arrayTask = new Task<List<WatchedFile>>[listeDirs.Count];
 
for (int i=0; i < listeDirs.Count; i++)
{
   string dir = listeDirs[i];
   int currentIndex = i; // Indispensable ici.
   arrayTask[i] = Task.Run(() => newListe[currentIndex] = MakeListeDir(dir) );
}
 
Task.WaitAll(arrayTask);

À noter qu'il est indispensable de copier l'index i pour une utilisation dans la closure. Sinon, il y a des problèmes en perspective ! (cf. closure et variable de boucle)

je ne suis pas expert en task, mais j'ai cru comprendre que ce n'était pas forcément exécuté sur un autre thread, mais parfois ça se partage un seul thread

C'est vrai pour les tâches gérées via async/await, où le contexte d'exécution est par défaut le contexte du thread courant. Par exemple, dans le cas des winform, le contexte d'exécution est le thread graphique. Donc monothread.

Sinon, sans précision particulière, les Task s'exécutent sur le contexte par défaut, qui utilise le pool de threads.

[daerlnaxe]

Merci,

J'avais noté pour l'index en effet car ç'a m'a rendu barge en fin de journée, sur un banal test pour lancer plusieurs tâches de durées différentes et de voir quelle solution permettait d'avoir vraiment les tâches séparées. Mais bêtement ça ne m'est pas venu à l'idée de faire un cliché de la valeur de i ce qui fait que je me prenais régulièrement un newListe[i]. Du coup je peux tout remettre en Task.run et je dirais "ouf!!". Puis le pire c'est que lorsque ça commence à partir en vrille à un moment donné tu ne trouves plus rien de bon, je moulinais.

Merci beaucoup ! Passez une bonne journée !

[François DORIN]

J'avais noté pour l'index en effet car ç'a m'a rendu barge en fin de journée, sur un banal test pour lancer plusieurs tâches de durées différentes et de voir quelle solution permettait d'avoir vraiment les tâches séparées. Mais bêtement ça ne m'est pas venu à l'idée de faire un cliché de la valeur de i ce qui fait que je me prenais régulièrement un newListe[i]

C'est certes un peu déroutant au début, mais c'est ce qui fait la force des closures : on capture des variables, et non la valeur des variables au moment où on crée la closure. La nuance est subtile mais implique un comportement qui n'est pas toujours évident à appréhender.