Dans mon code, j'ai une méthode avec plusieurs déclarations de capture, qui effectuent toute la même déclaration. Je ne suis pas sûr que c'est la bonne façon de la mettre en œuvre. Comment ferais-tu ceci? Voici comment ManiptionException ressemble à: P> private void HandleException(Exception exception)
{
// Load error control which shows big red cross
LoadControl(ControlDestination.Menu, "~/Controls/Error.ascx", null);
// Store error in database
DHS.Core.DhsLogDatabase.WriteError(exception.ToString());
// Show error in errorbox on master
Master.ShowAjaxError(this, new CommandEventArgs("ajaxError", exception.ToString()));
}
6 Réponses :
Vous le faites correctement (vous ne devez attraper que les exceptions que vous allez gérer et il n'y a aucun moyen d'attraper plus d'une exception type dans un seul Catch code> Block), mais comme une alternative , vous pouvez simplement attraper (exception ex) code>, vérifier le type d'exception et s'il n'est pas celui que vous n'êtes pas attendu, il suffit de lancer code> à nouveau, quelque chose comme ceci: catch(Exception ex) when (exceptionTypes.Contains(ex.GetType()) {
HandleException(ex);
}
Vous devez utiliser exceptionTypes.any (type => type.isAssiCablefrom (ex)) au lieu d'une simple comparaison d'égalité.
Vous avez raison, comme avec ce changement, des exceptions dérivées seraient également attrapées.
Il devrait s'agir d'exceptypes.ca (type => type.isAssiCableFrom (ex.getType ()))
Écrivez-le comme ceci:
try
{
// code that throws all sorts of exceptions
}
catch(Exception e)
{
HandleException(e);
}
Donc, cela devrait être: si (! Manipulez (e)) jette;
J'aurais refacteur comme suit: - Si j'utilisais vb.net, j'utiliserais des filtres d'exception pour faire des séries de captures. Mais comme nous utilisons c #, l'approche que vous avez est la plus efficace possible plutôt que de faire
@Az: hé, tout ce qui vous tourne sur: p
Je vais répondre à cela est de manière agenonneuse:
Faites ce que vous avez fait dans N ° 2, plus Modifiez la manuéeException pour ne gérer que certains types d'exceptions. De cette façon, vous ne devrez jamais faire de type TEM OUT une fois, et il est encore plus compact que ci-dessus. P> 1. code> Ce que vous avez fait maintenant est correct. Rien de mal à cela, sauf que cela pourrait être fastidieux si vous le faites plusieurs fois. p> 2. code> attrape la forme la plus générale d'exception qu'il y a. Tout simplement p> 3. Code> peut-être que vous ne voulez que prendre des exceptions, sans attraper toutes les exceptions em>, ce que vous avez ferait si vous venez de le faire # 2. P> private void HandleException(Exception e) throws Excpetion
{
// Reject some types of exceptions
if (!((e is FileNotFoundException) ||
(e is ArgumentNullException) ||
(e is HttpException ) ||
(e is IncorrectInheritanceException )))
{
throw;
}
//Rest of code
...
}
Je le ferais comme ça
Vous pouvez utiliser des génériques pour une solution beaucoup plus agréable tant que cela ne vous dérange pas d'utiliser aussi de Lambda. Je ne suis pas un ventilateur de la commutation de type. J'ai utilisé ce code plusieurs fois, je trouve qu'il est particulièrement pratique pour les proxy de service dans lesquels vous souhaitez gérer un certain nombre d'exceptions de la même manière. Comme cela a été indiqué ci-dessus, il est toujours préférable d'attraper le bon type d'exception dans la mesure du possible.
Le code fonctionne en spécifiant les exceptions en tant qu'arguments de type générique sur la fonction de la poignée. Ces types spécifiques sont ensuite capturés mais transmis à un gestionnaire générique comme classe de base. Je n'ai pas ajouté une poignée de main, mais cela peut être ajouté comme souhaité. Changez également de nommer à votre goût.
Ne pas attraper l'argumentation, l'éviter!
Je pense que c'est comme ça que je choisirais de le faire - oui c'est un peu long enroulé, mais vous êtes explicite de ce que vous faites et que vous vous permet de prendre des mesures supplémentaires, le cas échéant, dans chaque cas