Ist das Verschachteln von Try-Catch-Anweisungen immer noch ein Codegeruch, wenn es in einer Schleife verschachtelt ist?

Ich habe gehört, dass das Verschachteln von Try-Catch-Anweisungen oft ein Codegeruch sein kann, daher frage ich mich, ob diese Situation eine Ausnahme darstellt. Wenn nicht, welche guten Möglichkeiten zur Umgestaltung gibt es?

Mein Code sieht folgendermaßen aus:

try{
    X x = blah;
    otherStuff;
    for (int i = 0; i < N; i++){
        try{
            String y = Integer.toString(i);
            f(x);
        }
        catch(Exceptions1 e1){
            System.err.println(... + y + ...);
            System.exit(0);
        }
}
catch(Exceptions2 e2){
    ...
}

Ich benutze Exceptionshier, um einen Mehrfachfang anzuzeigen.

e2wird verwendet, um Ausnahmen zu fangen, die durch Initialisieren xund Ausführen ausgelöst werden otherStuff. Im Idealfall hätte mein Try-Catch nur diese beiden Zeilen umgeben, aber ich verwende sie xin meiner Schleife und wollte die Warnungen "nicht verwendete Zuweisung" vermeiden, die durch die Initialisierung auf Null außerhalb des Try-Catch verursacht werden.

e1wurde nicht mehrfach abgefangen, e2da ich dem Benutzer Informationen über Iterationsdetails bereitstellen möchte und daher einen catch-Block innerhalb der Schleife haben möchte.

Wenn der e2Fang, wie Sie sagen, nur dazu dient, Fehler beim Initialisieren xund Ausführen zu erkennen, können otherStuffSie ihn in eine separate Methode extrahieren. Dies trennt auch die Logik gut und ermöglicht es Ihnen, möglicherweise einen aussagekräftigen Namen zu vergeben otherStuff.

public X Foo() {
    try{
        X x = blah;
        otherStuff;

        return x;
    }
    catch(Exceptions2 e2){
        ...
    }
}

public void Bar() {    
    X x = Foo();
    for (int i = 0; i < N; i++){
        try{
            String y = Integer.toString(i);
            f(x);
        }
        catch(Exceptions1 e1){
            System.err.println(... + y + ...);
            System.exit(0);
        }
    }
}

Sofern Sie nicht beabsichtigen, die gesamte innere Schleife zu verarbeiten, unabhängig davon, ob eine Ausnahme auftritt oder nicht, entspricht Ihr Code im Wesentlichen

try{
    X x = blah;
    otherStuff;
    for (...){ 
       f(x)
    }
}
catch(Exceptions1 e1){
    ...
}
catch(Exceptions2 e2){
    ...
}

das erfordert keine Verschachtelung.

Wenn Sie weiterhin die Behandlung innerer Ausnahmen benötigen, überarbeiten Sie die innere Ausnahme und ihre einschließende Methode in eine neue Methode. Dies hat auch den zusätzlichen Vorteil, dass Sie gezwungen sind, über andere Möglichkeiten zur Verarbeitung der inneren Schleife nachzudenken. Ausnahmen können in Bezug auf die Leistung sehr teuer werden, wenn viele von ihnen geworfen werden.

Ich habe einige Bemerkungen zu Ihrer Frage:

1. In dem von Ihnen angegebenen Beispiel benötigen Sie überhaupt keine Ausnahmen. Sie müssten nur die Zeichenfolge y überprüfen, Fehler protokollieren und die Schleife verlassen. Nichts ist außergewöhnlich daran, dass Sie ungültig sind und protokolliert werden müssen. Die Tatsache, dass Sie in diesem Fall Ausnahmen verwenden, ist ein Hinweis auf Codegeruch.

2. Multi-Catch-Ausnahmen sind eigentlich nicht dazu gedacht, große Codestreifen zu verpacken und alles aufzufangen, was schief gehen könnte. Sie sollen helfen, zwischen Ausnahmen zu unterscheiden, wenn ein einzelner Codeabschnitt eine Reihe verschiedener Ausnahmen erzeugen kann. Da Sie Mutli-Catch-Ausnahmen als eine Art "Catch All" -Ansatz verwenden, weist dies auf Codegeruch hin.

3. Es macht keinen Sinn, einen Try-Catch in die Schleife einzufügen, es sei denn, Sie planen, den Rest der Schleife weiter zu durchlaufen, selbst wenn für eines der Elemente eine Ausnahme gefunden wird. Ihr Beispielcode zeigt, dass Sie planen, die Schleife zu verlassen, wenn ein Element außergewöhnlich ist.

Ich denke, Sie könnten mit so etwas wie besser dran sein:

try
{
     var x = blah;
     DoStuff();
     foreach(var i in icollection) // i is an int
     {
          var y = SomethingDependentOnI(i);

          // check y for explicit exceptional states
          if (IsSomethingWrongWithY(y))
               throw new Exception1(y);
     }
}
catch (Exception1 e1)
{
}
catch (Exception2 e2)
{
}

Dies ist viel klarer, leidet aber immer noch unter den oben beschriebenen Problemen.