Bonjour à tous,

Sur une production, je dois exécuter un traitement de données très lourd (env. 20 million de données) pour extraire des résultats statistiques.

Ces traitements s’effectuent en quatre étapes et sont indépendants.

Les méthodes :
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
 
private void Etape1() //Traitement 1
        {
            machines = new List<Machines>();
            paarung = new List<string>();
            paarung = AnalyserMachinesPako.Analyser("Paarung", typeSelection, gl.ListeAppairer, ref machines);
        }
 
        private void Etape2() //Traitement 2
        {
            machines = new List<Machines>();
            noPaarung = new List<string>();
            noPaarung = AnalyserMachinesPako.Analyser("NoPaarung", typeSelection, gl.ListeNonAppairer, ref machines);
        }
 
        private void Etape3() //Traitement 3
        {
            machines = new List<Machines>();
            klassierung1 = new List<string>();
            klassierung1 = AnalyserMachinesPako.Analyser("Klassierung1", typeSelection, gl.ListeClasseAiguilles1, ref machines);
        }
 
        private void Etape4()
        {
            machines = new List<Machines>();
            klassierung2 = new List<string>();
            klassierung2 = AnalyserMachinesPako.Analyser("Klassierung2", typeSelection, gl.ListeClasseAiguilles2, ref machines);
 
 
        }
       //........

Mon objectif est de gagner du temps sur ces traitements en lançant toutes ces méthodes en même temps. La plus lente serait le pacemaker.
Pour l’instant toutes mes solutions Thread, Parallel, PoolThread, Task ne me font rien gagner comme temps,
ce qui revient à faire ceci :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
        private void Traitement()
        {
 
            Etape1();
            Etape2();
            Etape3();
            Etape4();
        }

Voici des exemples que j'ai testé :
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
 
        private void Traitement()
        {
            var t1 = Task.Factory.StartNew(() => { Etape1(); Etape2(); Etape3(); tape4(); });
            t1.Wait();
        }
// Et
         private void Traitement()
        {          
            ManualResetEvent mre = new ManualResetEvent(false);
            Thread t = new Thread(
                () =>
                {
                    Etape1();
                    Etape2();
                    Etape3();
                    Etape4();
                    mre.Set();
                });
            t.Priority = ThreadPriority.Highest;
            t.Start();
            Thread.Sleep(1);
            mre.WaitOne();
}
 
//............
Le Wait et WaitOne attendent que chacune des étapes soient exécutées pour passer à la suivante donc je ne gagne rien.
En résumé, j’aimerais que l’exécution la plus lente masque les autres.

En vous remerciant pour votre aide !
Cordialement.