Catch-Blöcke mit genau demselben Code zusammenführen?

Question

Ich möchte die catch-Blöcke im folgenden Code aus Gründen der Wiederverwendung von Code zusammenführen:

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);
}

zu etwas wie diesem:

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);
}

Ist das irgendwie möglich?

Danke.

Answer 1

Vermutlich tun Sie das an mehr als einem Ort. Wenn ja, warum machen Sie das nicht?

{
    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 ...
}

Answer 2

Nein (oder zumindest: nicht, wenn die Ausnahmen, die Sie gruppieren möchten geschehen eine gemeinsame gruppenspezifische Basisklasse haben, was in Ihrem Beispiel nicht der Fall ist); das einzige, was Sie in diesem Szenario tun können, ist catch (Exception ex) und führen Sie Laufzeittests auf ex . Ich gehe davon aus, dass Ihr Code bereits "hübscher" ist, wenn Sie das getan haben (da Sie, was wichtig ist, den Bearbeitungscode bereits in eine Methode umstrukturiert haben).

Ich wäre versucht, die Abstände so zu verändern, dass ich mich auf die wichtig 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); }

(oder so ähnlich).

In gewisser Weise hängt dies auch mit dieser Frage zusammen: Schalter / Musterabgleich Idee .

Answer 3

So etwas könnte man nur machen, wenn man eine anständige Hierarchie von Ausnahmen hätte, dann könnte man eine Ausnahme eines Typs abfangen, der in der Hierarchie weiter oben steht. Ausnahmehierarchien sind jedoch so konzipiert, dass sie ziemlich flach sind, und es gibt keine Garantie dafür, dass Sie die Ausnahmen allein auf der Grundlage der Hierarchie auf die gleiche Weise behandeln möchten. Und außerdem... nichts davon würde bei den in Ihrem Beispiel verwendeten Standardausnahmetypen helfen.