Discussion :

[theMonz31]

Bonjour

Je me posais une petite question simple :

Insérer des block try/catch/finally, je sais que cela ampute les performances
d'un programme...

Mais j'aimerais savoir si quelqu'un a déja vu ou fait des rélevés de performances permettant de donner des métriques quand à l'utilisation du try/catch/finally
dans une application .Net

Dire que ca coute plus que de ne pas en mettre ok , mais quel cout ?

The Monz, Toulouse

[kheironn]

il n'y aurait pas une methode qui fait ces calculs ??? je crois que si... tu peux toujours la mettre en fin de code et tester...

ceci-dis à un moment ces blocs sont nécessaires sinon ton programme risque de te petter à la figure.

[Keihilin]

On en a déjà discuté au mois de juillet si ma mémoire est bonne, et j'avais donné un lien sur un article comportant un bench. Une petite recherche sur mes messages devrait te permettre de retrouver la conversation.

Au cas où elle a été supprimé, l'essentiel en quelques points :

• Ce qui coûte ce n'est pas tellement le try/finally, c'est surtout le catch.
• D'expérience, 90% des "catch" sont inutilement placés.
• Plus la complexité d'un traitement augmente, moins l'impact du "try/catch" est important.

[SirJulio]

Salut,

comme dit au dessus, le try/catch en soit ne coute rien (enfin si quelques branchements, mais c'est un cout fixe quelque soit le contenu de ta methode). C'est l'instanciation de ton exception ainsi que le rassemblement d'infos (stacktrace, etc )qui va te couter, mais uniquement si une exception est lancée. Si aucune exception n'est lancée alors, le cout est 'negligeable', puisque tu as juste, comme je disais au dessus, quelques branchement (principalement pour eviter le bloc protégé 'catch' si aucune exception). D'ailleurs à premiere vue, la CLR n'a meme pas connaissance de ce bloc protégé si aucune exception n'intervient (je regarde dans la norme du CLI pour etre sur), il sait juste qu'arriver en fin de catch, il doit brancher inconditionnellement (leave) sur le retour (ou le finally le ca echeant).

[theMonz31]

Ok super pour la réponse

Je marque en résolu... car les informations me comblent de bonheur
(enfin, presque )

The Monz, Toulouse

[Pol63]

et pour compléter, pour perdre des perfs que quand c'est nécessaire et peu prévisible, il vaut mieux tester beaucoup de choses plutot que de traiter les plantages nativement !
genre un dictionnaire, il vaut mieux tester avec contains puis accéder à la valeur plutot que de gérer un catch volontairement

[SirJulio]

Je viens de tester sur un petite source (perfectible, c'est juste pour voir la difference entre passage block protégé Vs passage bloc protégé + instanciation ex). Et ca confirme ce que je pensais. Le code :

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
class Program
    {
        static void Main()
        {
            int length = 100000;
            Stopwatch sw = new Stopwatch();
 
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                ExceptionFree.StaticMeth(true);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Static no ex handler: {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                ExceptionThrow.StaticMeth(false);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Static with handler no ex throw : {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                ExceptionThrow.StaticMeth(true);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Static with handler ex throw: {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            ExceptionFree e = new ExceptionFree();
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                e.InstanceMeth(true);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Instance no ex handler: {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            ExceptionThrow et = new ExceptionThrow();
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                et.InstanceMeth(false);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Instance with handler no ex throw : {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                et.InstanceMeth(true);
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("Instance with handler ex throw: {0} ticks ({1} ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds));
            sw.Reset();
 
            Console.Read();
        }
 
    }
 
 
    class ExceptionFree
    {
        public static string StaticMeth(bool dummy)
        {
            if (dummy) { }
            return "Passed";
        }
 
        public string InstanceMeth(bool dummy)
        {
            if (dummy) { }
            return "Passed";
        }
    }
 
    class ExceptionThrow
    {
        public static string StaticMeth(bool throwEx)
        {
            try
            {
                if (throwEx)
                    throw new Exception("Test");
 
            }
            catch (Exception ex)
            {
 
            }
            return "Passed";
        }
 
        public string InstanceMeth(bool throwEx)
        {
            try
            {
                if (throwEx)
                    throw new Exception("Test");
 
            }
            catch (Exception ex)
            {
 
            }
            return "Passed";
        }
    }

L'output debug :

Static no ex handler: 4086 ticks (1 ms)
Static with handler no ex throw : 5370 ticks (1 ms)
Static with handler ex throw: 11910858 ticks (3327 ms)
Instance no ex handler: 4413 ticks (1 ms)
Instance with handler no ex throw : 5702 ticks (1 ms)
Instance with handler ex throw: 12492151 ticks (3489 ms)

et en release

Static no ex handler: 365 ticks (0 ms)
Static with handler no ex throw : 3501 ticks (0 ms)
Static with handler ex throw: 11763809 ticks (3286 ms)
Instance no ex handler: 364 ticks (0 ms)
Instance with handler no ex throw : 3239 ticks (0 ms)
Instance with handler ex throw: 11535896 ticks (3222 ms)

D'ailleurs on peut voir que les optimisations en release n'impactent que peu les pertes de perf dues au throw de l'exception (donc cette perte est bien due à une instanciation/initialisation). On voit aussi que la perte de perf du à la simple presence du block protégé est vraiment negligeable.