Optimisation de l'appel Asynchrone

**smaouiomar** · 22/04/2011, 13h06

Bonjour,
J'ai une liste qui contient 30 000 objets de type MatchIn, et je dois les convertir en objetss de type MatchOut.
si je lance cette méthode de conversion dans un thread j'aurais un une liste d'objets convertis au bout de 10 minutes.

J'ai pensé à lancer chaque conversion dans une méthode asynchone.ainsi, je ferai 30 000 appels à des méthodes asynchrones.

-Je voulais savoir est ce que c'est pénalisant de lancer un grand nombre de traitement asynchrone? 30 000 dans mon cas.

-J'ai pensé à splitter cette liste à trois listes(par exemple) avec 10 000 element dans chaque liste et lancer unthread de conversion pour chaque liste.

- sinon est ce que vous avez d'autres propositions plus performantes.Merci

**smaouiomar** · 22/04/2011, 13h09

Voila une petit prototype:

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
public static void Main()
{
           for (int i = 0; i < 30000; i++)
            {
                MatchIn match = new MatchIn();
                match.Pro1 = i;
                listMatch.Add(match);
            }
            converter.ConvertAllMatches(converter.ConvertMatch, listMatch);
}
 
 
//Un Exemple simplifié de la classe d'entrée
    public class MatchIn
    {
        public double Pro1;
        public MatchIn(){}
    }
    //Un Exemple simplifié de la classe de sortie apres conversion
    public class MatchOut
    {
        public double Pro1;
        public MatchOut() { }
    }
    public class AsyncMatchConverter
    {
        List<MatchOut> maListeDeMatch = new List<MatchOut>();
        public delegate MatchOut DelegateToConvertionMethod(MatchIn arg);
 
        public MatchOut ConvertMatch(MatchIn match)
        {
            Thread.Sleep(2000);
            MatchOut result = new MatchOut();
            result.Pro1 = match.Pro1;
            Console.Write("-----------Fin de la conversion du mach");
            return new MatchOut();
        }
 
        private void ConversionCallback(IAsyncResult iar)
        {
            DelegateToConvertionMethod mc = (DelegateToConvertionMethod)iar.AsyncState;
            MatchOut result = mc.EndInvoke(iar);
            maListeDeMatch.Add(result);
            Console.WriteLine("-----------maListeDeMatch : element added[{0}]: total element count = {1}", result.Pro1, maListeDeMatch.Count);
        }
        public void ConvertAllMatches(DelegateToConvertionMethod convertFunc, List<MatchIn> listeDeMatchAConvertir)
        {
            AsyncCallback cb = new AsyncCallback(ConversionCallback);
 
            foreach (MatchIn matchIn in listeDeMatchAConvertir)
            {
                Console.WriteLine("-----------BeginInvoke: {0}", matchIn);
                convertFunc.BeginInvoke(matchIn, cb, convertFunc);
            }
        }
    }