Optimisation de l'appel Asynchrone

Version imprimable

22/04/2011, 13h06
smaouiomar

Optimisation de l'appel Asynchrone

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

Voila une petit prototype:

Code:

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);
            }
        }
    }

22/04/2011, 13h16
Aeronia

As tu essayé en utilisant un pool de thread (où le nombre de threads dans le pool est paramétrable) ?
22/04/2011, 13h53
smaouiomar

Oui Merci. c'est ce que je cherche :)