Faire le truc suivant dans une appli :  
Dériver Exception en MyAppException
qui serait la base de toutes mes exceptions.
Dans cette exception, créer un constructeur qui :
 1 - Appel le constructeur d'Exception (avec super ()).
 2 - Logue l'exception (dans un fichier).
 
c correcte selon vous ?
parce que ça serait fichtrement pratique !

je pense qu'il est mieux de garder les vraies exceptions, ne fut-ce que pour la trace
IOException, SQLException, etc.. si tu commences à lancer des exceptions customisées partout à la place, tu vas perdre toutes tes traces.
le coup du log ouais... mais bon.

non
 
Une exception c'est fait pour prévenir la couche supérieure d'un problème. Et donc c'est à ta couche supérieure de la catcher et de loguer.
 
Il ne doit y avoir aucun code business dans une exception

Ok, ok, j'le fais pas.
J'étais pas du tout sûr de mon coup en fait.

Ha... merci !

Ben moi, je trouvais que c'était une bonne idée.
Si toutes les exceptions que tu définis sont une sous-classe d'une exception racine que tu as défini aussi, moi, je trouve cela propre. Tu es sûr de pouvoir attraper toutes les exceptions de ton propre programme, tout en laissant passer les autres exceptions. Cela offre un très bon contrôle.
 
Maintenant, s'il s'agit d'encapsuler les exceptions standard, c'est différent. Quoique... Si tu as besoin de les enrichir avec d'autres informations qui te sont propres, pourquoi pas.
 
greg> De toute façon, quand tu conçois un logiciel un tant soit peu gros, avec plusieurs couches, il est largement préférable que chaque couche définisse ses propres exceptions. Sinon, pour être sûr que tu attrapes toutes tes propres cas d'erreur, soit tu es obligé d'ajouter un "throws Exception" à toutes tes fonctions, ce qui est horriblement crade et dangereux, soit tu te tapes une clause "throws" qui inclut plusieurs dizaines d'exceptions différentes, ce qui n'est pas top lisible (donc maintenable)...  
 
Le hic, c'est que si chaque couche a ses propres exceptions, tu es obligé d'avoir un mécanisme de type "je récupère les exceptions de la couche d'en-dessous, et je lève une des exceptions de ma propre couche"... ce qui fait que tu perds de toute façon trace des exceptions des couches basses.
 
La solution : à partir du JDK 1.4, il est possible de "chainer" les exceptions. Ainsi quand tu lèves une exception d'une couche donnée, tu lui attaches l'exception de la couche d'en dessous. La couche d'au-dessus récupérera donc bien une exception de la couche courante (pas une autre), mais tu n'auras pas perdu les exceptions des couches basses.
 
Et pour le debug, tu peux ensuite, à l'aide d'un outil approprié, consulter cette pile d'exceptions pour choisir le message et la pile d'exécution les plus appropriés pour comprendre le problème.
 
Avec un JDK 1.3.1 ou antérieur... pas le choix, il faut te faire ta propre classe "ChainedException" qui gère ce mécanisme de chainage d'exception.
 
Sinon, pour le coup du log, c'est une très bonne idée.

je suis pas tout à fait d'accord  

Mais encore ?      

ben j'ai la flemme

 
Tu ne pourras donc pas avoir raison ici...      
 
Allez, un peu de courage, ça m'intéresse, moi, tes arguments...  

plus tard

OK, j'attends.  

 
Sans blague ???

...Je suis pas bien avancé du coup moi !

Renaud> Pas de commentaire...