Fusionner des blocs catch avec exactement le même code?

Question

Je veux fusionner les blocs catch dans le code suivant pour des raisons de réutilisation de code:

try 
{ 
    DoSomeInputOutput(); 
} 
catch (InvalidOperationException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (InvalidDataException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentNullException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentOutOfRangeException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (ArithmeticException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (InvalidCastException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (Exception ex) 
{ 
    HandleUnknownException(ex); 
} 

à quelque chose comme ceci:

try 
{ 
    DoSomeInputOutput(); 
} 
catch (InvalidOperationException ex) 
catch (InvalidDataException ex) 
catch (ArgumentNullException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentOutOfRangeException ex) 
catch (ArithmeticException ex) 
catch (InvalidCastException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (Exception ex) 
{ 
    HandleUnknownException(ex); 
} 

Est-ce possible en quelque sorte?

Merci.

Answer 1

Non (ou du moins: non, sauf si les exceptions que vous voulez grouper se produisent pour partager une classe de base commune à ce groupe, ce qui n'est pas le cas dans votre exemple); la seule chose que vous pouvez faire dans ce scénario est catch (Exception ex) et faire des tests d'exécution sur ex. Au moment où vous avez fait cela, je m'attends à ce que votre code soit déjà "plus joli" tel quel (car, surtout, vous avez déjà refaçonné le code de manipulation dans une méthode).

Je serais tenté de modifier l'espacement afin que je puisse se concentrer sur le importante Code:

try 
{ 
    DoSomeInputOutput(); 
} 
// blah humorous scenario 1 
catch (InvalidOperationException ex) { HandleKnownException1(ex); } 
catch (InvalidDataException ex) { HandleKnownException1(ex); } 
catch (ArgumentNullException ex) { HandleKnownException1(ex); } 
// blah whimsical scenario 2 
catch (ArgumentOutOfRangeException ex) { HandleKnownException2(ex); } 
catch (ArithmeticException ex) { HandleKnownException2(ex); } 
catch (InvalidCastException ex) { HandleKnownException2(ex); } 
// unexpected comedy 
catch (Exception ex) { HandleUnknownException(ex); } 

(ou quelque chose).

D'une certaine manière, ceci est également lié à cette question: switch/pattern matching idea.

Answer 2

Vous ne pourriez faire quelque chose comme ceci si vous aviez une hiérarchie décente d'exceptions, alors vous pourriez attraper une exception d'un type plus haut dans la hiérarchie. Cependant, les hiérarchies d'exceptions sont censées être assez superficielles par conception et il n'y a aucune garantie que vous souhaitiez gérer les exceptions de la même manière uniquement en fonction de la hiérarchie. Et d'ailleurs ... rien de tout cela ne serait utile avec les types d'exception standard utilisés dans votre exemple.

Answer 3

Vraisemblablement, vous le faites dans plus d'un endroit. Si oui, pourquoi ne pas le faire:

{ 
    DoSomeInputOutput(); 
} 
catch (Exception ex) 
{ 
    HandleInputException(ex); 
} 

void HandleInputException(Exception ex) 
{ 
    if (ex is InvalidOperationException || ex is InvalidDataException || ex is ArgumentNullException) 
    { 
    HandleKnownException1 (ex); 
    } 
    else if ... 
    else if ... 
}