Faut-il désactiver les exceptions dans une application en production ?
4 réponses
Gilles TOURREAU
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production.
J'ai des fonctions qui contiennent du code permettant de vérifier la
validité des paramètres :
Par exemple :
public void MaFonction(int x)
{
if (x < 0)
throw ..... //Lever une excecption que x est négatif
....
}
Je voudrais savoir s'il faut garder ces vérifications lorsque l'application
est en production, ou faut-il les enlever à l'aide du pré-processeur comme
ceci :
public void MaFonction(int x)
{
#if DEBUG
if (x < 0)
throw .....
#endif
....
}
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Faust
ça dépend de ce que peut recevoir tes fonctions: si en production elles sont susceptibles de recevoir une valeur négative (pour l'exemple) dans un contexte d'utilisation normal alors il faut les laisser
si les exceptions n'ont été mises que dans un but de debuggage et qu'en utilisation normale, ces fonctions ne recevront jamais une valeur négative ou ne sont pas perturbées par une valeur négative alors ce type d'exception s'appellent des Assertions (je suis pas un spécialiste de la chose mais ça m'étonnerais que VS ne gère pas ce genre de chose)
et les assertions sont normalement automatiquement désactivées lors d'une compilation de type Release. Pas besoin de directives de compilation.
/_Gilles TOURREAU_ a émis l'idée suivante/ :
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production. J'ai des fonctions qui contiennent du code permettant de vérifier la validité des paramètres :
Par exemple :
public void MaFonction(int x) { if (x < 0) throw ..... //Lever une excecption que x est négatif
.... }
Je voudrais savoir s'il faut garder ces vérifications lorsque l'application est en production, ou faut-il les enlever à l'aide du pré-processeur comme ceci :
public void MaFonction(int x) { #if DEBUG if (x < 0) throw ..... #endif .... }
Cordialement
-- Mephitiquement votre, Faust ICQ #161252577
ça dépend de ce que peut recevoir tes fonctions: si en production elles
sont susceptibles de recevoir une valeur négative (pour l'exemple) dans
un contexte d'utilisation normal alors il faut les laisser
si les exceptions n'ont été mises que dans un but de debuggage et qu'en
utilisation normale, ces fonctions ne recevront jamais une valeur
négative ou ne sont pas perturbées par une valeur négative alors ce
type d'exception s'appellent des Assertions (je suis pas un spécialiste
de la chose mais ça m'étonnerais que VS ne gère pas ce genre de chose)
et les assertions sont normalement automatiquement désactivées lors
d'une compilation de type Release. Pas besoin de directives de
compilation.
/_Gilles TOURREAU_ a émis l'idée suivante/ :
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production.
J'ai des fonctions qui contiennent du code permettant de vérifier la validité
des paramètres :
Par exemple :
public void MaFonction(int x)
{
if (x < 0)
throw ..... //Lever une excecption que x est négatif
....
}
Je voudrais savoir s'il faut garder ces vérifications lorsque l'application
est en production, ou faut-il les enlever à l'aide du pré-processeur comme
ceci :
public void MaFonction(int x)
{
#if DEBUG
if (x < 0)
throw .....
#endif
....
}
ça dépend de ce que peut recevoir tes fonctions: si en production elles sont susceptibles de recevoir une valeur négative (pour l'exemple) dans un contexte d'utilisation normal alors il faut les laisser
si les exceptions n'ont été mises que dans un but de debuggage et qu'en utilisation normale, ces fonctions ne recevront jamais une valeur négative ou ne sont pas perturbées par une valeur négative alors ce type d'exception s'appellent des Assertions (je suis pas un spécialiste de la chose mais ça m'étonnerais que VS ne gère pas ce genre de chose)
et les assertions sont normalement automatiquement désactivées lors d'une compilation de type Release. Pas besoin de directives de compilation.
/_Gilles TOURREAU_ a émis l'idée suivante/ :
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production. J'ai des fonctions qui contiennent du code permettant de vérifier la validité des paramètres :
Par exemple :
public void MaFonction(int x) { if (x < 0) throw ..... //Lever une excecption que x est négatif
.... }
Je voudrais savoir s'il faut garder ces vérifications lorsque l'application est en production, ou faut-il les enlever à l'aide du pré-processeur comme ceci :
public void MaFonction(int x) { #if DEBUG if (x < 0) throw ..... #endif .... }
Cordialement
-- Mephitiquement votre, Faust ICQ #161252577
Michael Moreno
> et les assertions sont normalement automatiquement désactivées lors d'une compilation de type Release. Pas besoin de directives de compilation.
en effet, voir System.Diagnostics.Debug.Assert();
-- Michael ---- http://michael.moreno.free.fr/ http://port.cogolin.free.fr/
> et les assertions sont normalement automatiquement désactivées lors d'une
compilation de type Release. Pas besoin de directives de compilation.
en effet, voir System.Diagnostics.Debug.Assert();
--
Michael
----
http://michael.moreno.free.fr/
http://port.cogolin.free.fr/
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
"Michael Moreno" <michael.ToRemove.moreno@free.fr> a écrit dans le message
de news: mn.b2df7d633b77a530.21643@free.fr...
et les assertions sont normalement automatiquement désactivées lors d'une
compilation de type Release. Pas besoin de directives de compilation.
en effet, voir System.Diagnostics.Debug.Assert();
--
Michael
----
http://michael.moreno.free.fr/
http://port.cogolin.free.fr/
Société P.O.S Spécialiste en motoculture depuis + de 30 ans ! http://www.pos.fr "Michael Moreno" a écrit dans le message de news:
et les assertions sont normalement automatiquement désactivées lors d'une compilation de type Release. Pas besoin de directives de compilation.
en effet, voir System.Diagnostics.Debug.Assert();
-- Michael ---- http://michael.moreno.free.fr/ http://port.cogolin.free.fr/
adebaene
Gilles TOURREAU wrote:
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production. J'ai des fonctions qui contiennent du code permettant de vérifier la validité des paramètres :
Par exemple :
public void MaFonction(int x) { if (x < 0) throw ..... //Lever une excecption que x est négatif
.... }
Je voudrais savoir s'il faut garder ces vérifications lorsque l'applica tion est en production, ou faut-il les enlever à l'aide du pré-processeur comme ceci :
public void MaFonction(int x) { #if DEBUG if (x < 0) throw ..... #endif .... }
Surtout pas!
Si le cas "anormal" (x<0 dans ton exemple) se produit, il vaut bien mieux planter immédiatement l'application plutôt que de la laisser continuer en ignorant silencieusement l'erreur : l'utilisateur rale quand une application plante, mais c'est moins grave que d'avoir une application qui produit des résultats complètement faux (ou pire, efectue des opérations fausses ayant des conséquences graves).
Bien sûr, la "bonne" solution consiste à attraper les erreurs plus haut dans la pile d'appel avec un catch et à les traiter...
Arnaud MVP - VC
Gilles TOURREAU wrote:
Salut tout le monde !
J'ai une application qui va passer dans pas longtemps en production.
J'ai des fonctions qui contiennent du code permettant de vérifier la
validité des paramètres :
Par exemple :
public void MaFonction(int x)
{
if (x < 0)
throw ..... //Lever une excecption que x est négatif
....
}
Je voudrais savoir s'il faut garder ces vérifications lorsque l'applica tion
est en production, ou faut-il les enlever à l'aide du pré-processeur comme
ceci :
public void MaFonction(int x)
{
#if DEBUG
if (x < 0)
throw .....
#endif
....
}
Surtout pas!
Si le cas "anormal" (x<0 dans ton exemple) se produit, il vaut bien
mieux planter immédiatement l'application plutôt que de la laisser
continuer en ignorant silencieusement l'erreur : l'utilisateur rale
quand une application plante, mais c'est moins grave que d'avoir une
application qui produit des résultats complètement faux (ou pire,
efectue des opérations fausses ayant des conséquences graves).
Bien sûr, la "bonne" solution consiste à attraper les erreurs plus
haut dans la pile d'appel avec un catch et à les traiter...
J'ai une application qui va passer dans pas longtemps en production. J'ai des fonctions qui contiennent du code permettant de vérifier la validité des paramètres :
Par exemple :
public void MaFonction(int x) { if (x < 0) throw ..... //Lever une excecption que x est négatif
.... }
Je voudrais savoir s'il faut garder ces vérifications lorsque l'applica tion est en production, ou faut-il les enlever à l'aide du pré-processeur comme ceci :
public void MaFonction(int x) { #if DEBUG if (x < 0) throw ..... #endif .... }
Surtout pas!
Si le cas "anormal" (x<0 dans ton exemple) se produit, il vaut bien mieux planter immédiatement l'application plutôt que de la laisser continuer en ignorant silencieusement l'erreur : l'utilisateur rale quand une application plante, mais c'est moins grave que d'avoir une application qui produit des résultats complètement faux (ou pire, efectue des opérations fausses ayant des conséquences graves).
Bien sûr, la "bonne" solution consiste à attraper les erreurs plus haut dans la pile d'appel avec un catch et à les traiter...
